{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Randomized measurements\n",
    "\n",
    "This tutorial shows the different randomized measurements of the `povm_toolbox`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Circuit and Observables\n",
    "\n",
    "We first look at a random the 2-qubit circuit, with depth 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXEAAADuCAYAAADPwDeGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAhpUlEQVR4nO3deVyVdd7/8dc5sguC4IKIu+C+I4YylVtpltpemmZZ8+vO0plMZnKaKacax7SycrynJmfazGzQKdMWKylxTUVyQ1EUYzsqAiKLrOf3B7enGA4qdOBwHd/Px8PHzLmu73Vdn+uC3lzney1fk9VqtSIiIoZkdnYBIiJSfwpxEREDU4iLiBiYQlxExMAU4iIiBqYQFxExMIW4iIiBKcRFRAxMIS4iYmAKcRERA1OIi4gYmEJcRMTAFOIiIgamEBcRMTCFuIiIgSnERUQMTCEuImJgCnEREQNTiIuIGJhCXETEwBTiIiIGphAXETEwhbiIiIEpxEVEDEwhLiJiYApxEREDU4iLiBiYQlxExMAU4iIiBqYQFxExMIW4iIiBKcRFRAxMIS4iYmAKcRERA1OIi4gYmEJcRMTAFOIiIgbm5uwC5JexWq2UF5c4uwyX5ebticlkavTtGvHn6uhjZbRj4KzfFYW4wZUXl7Cy233OLsNlTU15H3cfr0bfrhF/ro4+VkY7Bs76XVF3ioiIgSnERUQMTCEuImJgCnEREQNTiIuIGJhCXETEwBTiIiIGpvvERVxIcFQfxq1dUG1aWWEx+cezSIndTNKKz7BWVDqpOmkICnERF3R8bTzpmxLAZMK7dQDd77yOyAUz8A9rz/Z5bzi7PHEghbiICzq7/wTH18TbPh95+0tujX+V8CmjSfjrKkrO5juxOnEk9YmLXAXKi0s4k3AUk9lMi05tnV2OOJBCXOQq4de5KrxL8gqcXIk4krpTRFyQm7cHnoF+tj7xHtNvIKhfV84kHCX/eJazyxMHcvkz8ezsbGJiYujevTteXl506NCBOXPmUFhYyMyZMzGZTCxbtszZZYo41KCYe7j34L+498A/mRz3Mr0eGEfqhh1smrHI2aWJg7n0mXhiYiLjx4/HYrHQvHlzevfuTWZmJq+99hopKSnk5OQAMHDgQOcW2pBMJno/PIEe08biG9qaC2fzOfHpNhJfXG2odzVL3Rx5byOpn27H7O5Gy54d6TtrMs3bBVFRUmprY/Zw45aNiznxn3j2vbrWNj166Sy8Wgfw9dQXnFG6Q1285XLXgnc5+Pd1dtvMyIol7as9fDN9YSNX5xgueyaenZ3NLbfcgsViYe7cuWRlZZGQkIDFYmHRokVs2LCBXbt2YTKZ6N+/v7PLbTCRf55B5IIZ5CWns+Ppf5K6fju9Z97E6Hd/D054gb00jvzjFrLi95OxaS8Hln/CN/f/lVYDuxG16P/Z2lSWlrNl9uv0m30bLXt3AqDjuKGEjo1g6xPLnVW61JHLhvjs2bNJT0/nscceY8mSJfj5+dnmxcTEMGDAAMrLy+ncuTMtWrRwYqUNJyA8lF4Pjid1ww7iZi7m6Mqv2fXsO3z/7Du0i+5Hl8kjnF2iNJIzu4+QEruZLpNH0Dqih2362X3HOfi/6/jVa4/j0y6QqMWPsHP+WxSfynVitVIXLhniSUlJrF69mlatWrFwof2vSEOGDAFgwIAB1aafOHGCiRMn4ufnR8uWLZk+fTpnz55t8JobQpdbozGZzRz6x4Zq04+u/Jqyogt0u/1aJ1UmzvDDK7FUllcwaN7d1acvXUNlRQUTv1qMZesBTnyy1UkVSn24ZIivWrWKyspKpk6diq+vr9023t7eQPUQP3/+PCNHjiQ9PZ1Vq1bx5ptvEh8fz80330xlpfEeVW41sDuVFRVk7z1abXpFSRk5B1JpNbCbkyoTZzifauHEJ1sJubY/bYb1sk23lldwZtcRvIL8ObY6zokVNpyLd+vY+2d0Lnlhc9OmTQCMHDmy1jbp6elA9RB/8803ycjIYPPmzXTs2BGA0NBQhg8fzrp165g8eXLDFd0AfNq2pCTnPJWl5TXmFVlyaBvZE7O7G5VlNeeLa9r36hq6TB7BoHl38+UdzwLQZlgvut89kqQVnxH55wdYN3YeFRdKL70igxkUcw+DYu5xdhkNwiVD/OTJkwB06tTJ7vzy8nK2bq36yvjzEF+/fj3R0dG2AAeIioqia9eufPrpp/UO8YiICCwWS72WvRx3q5lniLQ7r5m3JxWlZXbnVZRUTXfz9qBUIV6r8LBwykyN/y3sUj/XS7FsP8jb7e6odf65oxm8G/pTd4qbjxfRS2ex54WVHH7nS8b/588MfmoKu555u87bdvSxqu8xsOfi3Tr23PjRMw7Zxi/d/+DgYHbv3l3n5VwyxAsLCwEoLi62O3/16tVkZ2fj5+dHly5dbNMPHTrEnXfeWaN9nz59OHToUL3rsVgsZGRk1Hv5S/EwNYNanqKuKC7Bvbm/3XnNPN0BKC92rTMuR8vMyqTUWtHo273Uz9WRhj47nYIfT3P47S8A2DJnGRO/XsKPn+/k1I6kOq3L0cfKkcfg4t06DclZvysuGeLBwcHk5uaSkJBAVFRUtXlZWVnMmzcPgP79+2P62W12ubm5BAQE1FhfYGAgR44c+UX1NBR3qxlq+eNfdCoX//BQzB5uNbpUfIIDuXD2nLpSLiOkXYjTzsRr+7k6SvtRg+gycQSfjJ5rm3b+5Cn2vLCSEa/MYt2ouXV6lsDRx6oxjoEj/dL9r29OuGSIjxkzhqSkJBYtWsTYsWMJDw8HYNeuXUybNo3s7Gyg8R7yqc9XpCtVVnSBld3uszsvO/EY7a8fSKtBYZze+dNZVTNPdwL7dq7zmdbVKPloMu4+Xo2+3Uv9XB0lY9NePuh5f43ph9/+wnZmXheOPlaNcQwcyVm/Ky55d0pMTAxBQUGkpaXRp08f+vXrR1hYGJGRkXTt2pVRo0YBNW8vbNmyJXl5eTXWl5OTQ2BgYGOU7lAnPtmGtbKS3g9PqDY9bOoY3H28OL52s5MqExFHcckQDw0NJT4+ngkTJuDl5UVqaiqBgYG88cYbbNiwgeTkZKBmiPfq1ctu3/ehQ4fo1atXjelNXd7hHzn8ry/oPOEaRq6YR9iU0UQ8M53IZ+/Hsu0gx9ducXaJIvILuWR3ClQF8vr162tMLygoIDU1FbPZTN++favNu/nmm5k/fz7p6emEhoYCsHPnTlJSUli8eHGj1O1o3//pbQrSzhB+3xhCRw/mQk4+Sf/8nL0vrgar1dnlicgvZLJar67/knfu3Mk111xDjx49OHz4cLV5+fn59OvXj1atWrFgwQIuXLhATEwMrVu3Zvv27ZjNTe+Li9H6DY1masr7Ltsn7miOPlZGOwbO+l1peqnUwPbvr7rN6L+7UgBatGjBpk2baNeuHffccw8PPfQQw4cPZ/369U0ywEVEXLY7pTaXCnGAbt262e2GEWnK7vh+ORUlZbYnLfe9/h9S122r1qb73SPp/dBNts8+IUGc2pFE3MzqXYXRS2fR/e6RfNBjOqX5RQ1fvPwiCnERF/HdI6+QczC11vnHVsdVezfKpLiXa9yh1PGmYVSWN/4DK1J/V12IX3yvisjVrNWgMLxa+fPjlz89w+DVyp/+s2/ji9ufIXzqGCdWJ3Vx1YW4iKuKfu1xTCY4s/cYe/6ykpKz+bW2DZsyipTY77D+7Kx7+JJH2P3ce5QXXmiMcsVBdLVOxAV8fuufWDd6LutuiKEk5zy/evWxWtu6eXvSZdIIjq766Vtp2JTRFGZkY9l6oDHKFQdSiEutAnp0YHraatpd61rD13m3DuC+4yvpdud1zi7FYQozql4lYS2v4NA/1tN2WO0Pp3W+JYq8I2mcS063TQse0ZeONw7lju+Xc8f3VUOzTdz0EoF9u9S2GmkiFOJSq6ELZnB612GyNu8DYPBTU5iRFUv3e0bZbT9uzQKmpa4ioEcHoOqPwLTUVYxbs8Bu+7B7RzEjK5ZBv7+3xryeD45nRlYs/WbfZndZjwBf7kr8B7fv/Fud2ro196L4TB5H3t3I4N9PoZm3x2WPQ1Pn5u2JRwsf2+cut0Zz9sCJWtuHTRld7SwcIH7Wq/w74hFiIx8lNvJRANaNmkvOJdYjTYNCXOxqPSSc9tcN4OAbP91umbjkI3KTThL57P34tKv+Lpnev76Z4OF9SFyymrwjaQDkHUkj8eV/Ezy8D71m3lStffPQVgx99n5yDp3kh5f+XWP7h//5OZnx+xn4xJ207FXzvfDX/OUhvFv7s/U3y+vU9mJ/b9Jbn+ET3JKwu+3/QTISr9b+3Bi7gInfvMSkTS8RfE0ftjz+OlDVz93hhghb2xbdQgjs01lDsLkQhbjY1XPGjVw4e470bxJs0yrLyomfsww3H09GvPyobXqLbiEM/v29nNmTzIHl66qt58Cyjzmz9yiD50/Br/NPr9oc8fIsmnl5sGXOslpfh7v1ib9RUVJK9KuPYXJrZpve8aZhdL01mkNvfYZl+8E6twUoSD/DqZ1JhE8bW88j1HQU/HiaT2+Yx7rRc/lk1Fw2PbCIgvQzAGx78u+kbfzpDpT8lExWhk277MXLt9vdoXvEDUIhLjWYmpnpOC6SzM37q929AJCz/wT7Xv8P7a8fSPh9YzCZzfzqtccBiJ+zDOt/jUVqraxky5xlmM1mopfOApOJng+OJ+RX/di3dM0lv64Xpmfz/TPvENSvCwOfqBqswzPQj6i/Psy5YxkkLPygXm0vyti0l8DenfDvHlK/AyXSBCjEpYag/t1w9/UmO/GY3fk/vBJLzoETRPxpOsNeeJDWg8NIWLSK/JRMu+3PHc0g4cUPaTusF8Oee4Ahf5hK9r4U9r229rK1HPtwE2kbd9PvsckEDejGNQsfxrOlH/GPv15jHMi6tAU4vafqbZbBw/vWmCdiFApxqSEgvOoNjudT7Y8Lai2vIH7OMpp5utNzxjhO7Uzi0JsbLrnOg3//lNO7jtBr5k2YmzVjy+xlWCuubBSUbU/+ndLzRYxdOZ8uE4ezf9l/av0DU5e2F/fv4v6KGJFCXGrwCmoBQEleQa1tyvKLbEO+pX+TcPnX2lqttvXlp1o4d/TKxxwtPpPHzj+swCvIn9ykkyTauRBan7YluVX1eLWyPw6piBEoxKUG29uJfzb+6H8bsXQWZnc38pLT6P+b2/HrdOkRbbvfPZIOY4dwdv8JWvboQN9Zk6rNN7u74d06oNo/t5+91vPM7qquj7P7jtfop/9vV9z24u5dVS9jFlejx+6lhouPa3sG+Nqd32vmTbQb0Zc9Cz8g7YvvuWXjYka88ihf3PaM3fY+IUFELphBbtJJPrtlPmM//CMDn7iTH7/cZXvgpE1ED8atrX4/eeKSj0h86SMH7ll1F/fvwtlzDbaN+nLz9mRqyvvOLqNO3Lw9Hb4+Rx+DtcMfp/hULt5tW3Lbttcdum5H7/8Vb9cpW5UmLff/7vNu0aVdjXl+XYIZPH8KZ/Ye5cCyj7FWVpL40kcMmT+VXjNvImnFZzWWGfHyo7j5eBI/ZxkVJWVs/e1yJn6zhOils/js5j9grawk51AqX95VPcTPnzzVMDv4f1p0rtq/i/vblJhMJqcMMNCUNMQxMJlNtv91leOr7hSpIWf/CUrzC2k9JKz6DJOJ6KWPYTab2fKz2wkP/O0TshOPVd0L/l/dKj2m30D76waw7/X/kLO/6nbC86kWEhZ+QOtBYbZuldJzhWTF76/2r+DH0w26nxf379TP7h8XMRqFuNRgrazk5Gc7aRfdD7PHT1/W+jxyC20je7J38epqFyZt94I3a8aIV356CMi3Qxsi/jiNnAMn+OGV2GrbSHrrMyw7DjHwiTvxd9LdIe1HDybn0EnOHbN/a6SIESjExa4j72zEM8CXDmOHAOAf1p7BMfdwevcRDv790xrt85LTSXzpI4KjfnrEPnrpLMweblUPAdm5wLj1t8uprKwkeuksTI08/J1vaGvaRvYk+b2vGnW7Io521Q2U7GoacjDZsR/8ATcfLz6f/McGWb8zDV0wg843R7E2+nEqims+CHSRswa/lYbx0eBfU5SVg0+7QO5KeNPZ5TiEzsSlVruefYfWQ8IJuc61hrLzbhNAj2ljSfjrB5cMcBEj0N0pUqu85HTe7XC3s8twuOLTebzfdaqzyxBxCJ2Ji4gYmEJcRMTAFOIiIgamEBcRMTCFuIiIgSnERUQMTCEuImJgCnEREQNTiIuIGJie2JRLinzuQTreGIFvhzasG/MkOQdT7bbrfvdIej90k+2zT0gQp3YkETdz8WW3ETpmCEOfmY7JbCb38I9smbOMsoLiGu16zbyJ8PvGgNWK1QoHln/M8TXxVdu/63oin3vA9vraknOFfHnHswD0n3MbnW+Osq3Ht1Nbjn7wDbuefedKD4NIk6UQl0s6uWE7B5Z/zE2fPH/JdsdWx3FsdZzt86S4lzm+dvNl1+/m48WIl/+HL277E+eOZTLshZkM+O0d7H7uvRpt846k8dnEpyk7X4RPSBATv1rMmd3JtsEjLNsOsumBF2sst+/Vtex7dS0AZg837tr7D46vjb9sbSJGoBCXSzq1I6nOy7QaFIZXK39+/HL3Zdu2HzWInAMnbO/0PvzOl9yw6o92Qzxry37b/y/KPEvx6Tyah7Sq0whAHcdFUpSZzdl9x694GWewWq0UFZc7u4w68fF2w3SJcVmlYSjExeHCpowiJfa7yw5oDODbvhUF6WdsnwvSTuPdNgBTMzPWispal2v3q354+DcnO/GYbVqbyJ5M/Gox5cWlHHxzPSfXb7dT22iSV22q4x41vqLicnyvedfZZdRJwY7pNPdxd3YZVx2FuDiUm7cnXSaNYMPN8xtsGwE9OxL9yiy+e+QVyotLAEj7eg8nPt1GRXEp/mHtuWHVHynKzOZMwlHbcs1DW9E2siffPfJKg9Um0th0d4o4VOdbosg7kmYbxf5yCjKy8Q1tbfvs26ENxafyaj0L9w8PZcx7T7HlieWc/v6wbXpJznnbu8HPHc0gfVMCbYb2rLZs2N2j+PGLXZTmFdR1t0SaLIW4OFTYlNEctdNdcWv8q/gEB9aYnhG3l8B+XfHvHgJAz/tv5MQnW+2u2z+sPWPfn8+2eX8na/O+avN+vm6vVv60G9GPswdO/NTAZKL7PSM5uuqb+uyWSJOl7hS5pKgXf03o6CF4twlg7KqnKSsoZu3wxwEYvuQR0jbuJm1j1QXMFt1CCOzTuUYIewW1wLOlLyV2zoDLCy+wbe7/Mupfv8PUzEzekTTiZy+zzZ/41WK+uu8vFJ/KZdhzD+Lu50PEH+6DP1QNSbf7hffJ/PYHej4wjg43DsVaVg5mMwffXI9l6wHbekKu7Y+1spKs+P01ahAxMo2xaXANOcamo3S6OQr/7iHsW7rG2aXUmbPG2CwsKtOFzQbgimNs6kxcGpy9u0RExDHUJy4iYmAKcRERA1OIi4gYmEJcRMTAFOIiIgamEBcRMTCFuIiIgV0VIZ6dnU1MTAzdu3fHy8uLDh06MGfOHAoLC5k5cyYmk4lly5ZdfkUiYlgleQVUlJQBUFFSRml+oZMrcgyXf9gnMTGR8ePHY7FYaN68Ob179yYzM5PXXnuNlJQUcnJyABg4cKBzC20g/R6/laB+XQnq3xW/Tm0pSDtNbOSjzi5LnOS6iGC+/ecEnnxpJy+9c+DyC7iAnEOpJK34nONr46m4UPWStJKc83w08Nd0vf1aej10Ey17dHBylfXn0mfi2dnZ3HLLLVgsFubOnUtWVhYJCQlYLBYWLVrEhg0b2LVrFyaTif79+zu73AYxZP5Ugkf05XyqhZLc884uR6RRpcRuZv2433H0g29sAX5ReXEJye9/xac3zOPEum1OqvCXc+kQnz17Nunp6Tz22GMsWbIEPz8/27yYmBgGDBhAeXk5nTt3pkWLFk6stOHEDnuUD/s8wMZ7nqPoVK6zyxFpND9+uYstc16nsuzSg5NUlpaz+dGlpG/a20iVOZbLhnhSUhKrV6+mVatWLFy40G6bIUOGADBgwADbtIuhHxkZiaenp+GHm7o4cLDI1aSyrJwdv/8H1sore7+ftaKSHU/9g8qKy49G1dS4bIivWrWKyspKpk6diq+vr9023t7eQPUQP3bsGGvWrCE4OJihQ4c2Sq0i4lhpG3dTZMmp0zIFP54m89sfGqiihuOyIb5pU9XABCNHjqy1TXp61egzPw/xa6+9lqysLNatW8eYMWMatkgRaRDH/v1t/ZZbHefYQhqBy96dcvLkSQA6depkd355eTlbt1YNXvDzEDebHf93LSIiAovF4vD1ArhbzTxDZIOsWyA8LJwyU+0DNjeUStwh8OlG3+4vERYejpkyZ5cBwKMV/QiheZ2X2/zpRu4Ldc4YrMHBwezevbvOy7lsiBcWVt0DWlxcbHf+6tWryc7Oxs/Pjy5dujRoLRaLhYyMjAZZt4epGbRtkFULkJmVSanVCf2kJg+oOZpdk5aVmQnW0ss3bARlQT3Ave4hXlpaSkZOw/y32lBcNsSDg4PJzc0lISGBqKioavOysrKYN28eAP3792/wi5fBwcENtm53qxka/0TxqhHSLsRpZ+JZjb7VX6ZdSEiTORMvrKjfgGXFntC+fXsHV3Nl6psTLhviY8aMISkpiUWLFjF27FjCw8MB2LVrF9OmTSM7OxtonId86vMV6UoZYXg2I0s+mqzh2a7Q0eTkJjM828nPvyfuwRfrvNxv33+Zl0YNaoCKGo7LXtiMiYkhKCiItLQ0+vTpQ79+/QgLCyMyMpKuXbsyatQooHp/uIi4hg5jh+ATElSnZfw6taX99cbLA5cN8dDQUOLj45kwYQJeXl6kpqYSGBjIG2+8wYYNG0hOTgZcP8S73nEt/X9zO/1/czteQS1w9/Oxfe56x7XOLk+kQZjdmhG16NeYzFfWVWqytTdeJLpsdwpAr169WL9+fY3pBQUFpKamYjab6du3rxMqazzh944meHifatMG/+5eACzbDnI8drMzyhJpcB3GDOHa5b8hfvbrVJaW19qumac71y7/DSHXGfOEzqVDvDYHDx7EarUSHh6Oj49PjfmxsbEAHDp0qNrnzp07ExER0XiFOsAXtz/j7BKkCflutwVT/xXOLqPRdJk0gpY9O5L0z89Jif2O8qIS2zx3X2+63XkdPR8YT0CYcy5mOsJVGeL79+8Hau9KufPOO+1+vv/++3n77bcbtDYRcayAHh2IWvRrhjx9Hzn7T1BWWIx7c2+C+nfF3dfb2eX9YgpxO6zW+t2eJCJNl4efT42uRVdgvF58B7hciIuIGMVVeSZ+8b0qIiJGd1WeiYuIuAqFuIiIgSnERUQMTCEuImJgCnEREQNTiIuIGJhCXETEwBTiIiIGphAXETEwhbiIiIEpxEVEDMxk1Sv7DM1qtVJeXHL5hlIvbt6eDT6Qtj1Wq5Wi4toHMmiKfLzdnHKsrnYKcRERA1N3ioiIgSnERUQMTCEuImJgCnEREQNTiIuIGJhCXETEwBTiIiIGphAXETEwhbiIiIEpxEVEDEwhLiJiYApxEREDU4iLiBiYQlxExMAU4iIiBqYQFxExMIW4iIiBKcRFRAxMIS4iYmAKcRERA1OIi4gYmEJcRMTAFOJNxObNm5k0aRKdOnXCZDLx/PPPO7skETEAhXgTUVBQQO/evXnxxRcJDg52djkiYhAmq9VqdXYRUl3nzp156KGHePrpp51diog0cToTFxExMIW4iIiBKcRFRAxMIS4iYmAKcRERA3NzdgFSpaCggGPHjgFQWlqKxWIhMTERX19funfv7uTqRKSp0i2GQH5+Pn/5y19Ys2YNaWlp+Pv7Ex0dzVNPPUVERESj1PDtt98ycuTIGtOvu+46vv3220apQUSM56oP8dOnTzN8+HBSUlLw8vKid+/eZGZmYrFYcHNz48MPP+T22293dpk2J9KyCA1ujbu7vkSJiPrEefDBB0lJSWHYsGGcPHmSPXv2kJ6eznPPPUd5eTnTp08nIyPD2WUCcL6giBUffcaLb37IufwCZ5cjIk3AVR3ie/bsYcOGDbi5ubFq1SratGkDQLNmzXj66acZOXIkRUVFLFmyxMmVVvlu5w+Ul1fQsoUfLfyaO7scEWkCXDLEKyoqeO+997jhhhto3bo1np6edOzYkXHjxvHWW29RUVEBwJo1awAYPXo0Xbp0qbGehx9+GIDY2NjGK74W5wuK2JF4CIAx0UMwmUxOrkhEmgKXC/H8/HzGjh3L9OnT+eqrr/Dw8GDAgAFUVlayceNGHn74Yc6fPw/Ajh07AIiOjra7rovT09PTSU9Pb5wdqMXFs/COIW0J69zeqbWISNPhclfHZs6cSVxcHKGhobz77rvV7vg4deoUK1aswN3dHYDk5GQAunXrZnddoaGheHh4UFpaSnJyMqGhofWq6fV31nK+oLheywJYrVbOFxYBkJ17joXLP6j3ukSkafLz9ebx+2+r83IuFeJ79uwhNjYWNzc3Pv/8c/r27Vttftu2bZk/f77tc25uLgAtW7a0uz6TyURAQACnT5+2ta2P8wXF5BcU1nv5nysqvuCQ9YiIa3CpEP/4448BmDBhQo0At+fChapA9PDwqLWNp6cnAMXF9T+T9vP1rveyPz8L9/H2wq1Zs3qvS0SarvrmhEuF+KFDVRf+oqKirqi9l5cXRUVFlJaW1tqmpKQEAG/v+gdxfb4iXbT+m+1s2b2fjiFt+Z/7JuqCpohU41Ihnp+fD4C/v/8VtW/ZsiVFRUW1dpVYrVby8vJsbeurvn3i6gsXuXqoTxxo0aIFAOfOnbui9uHh4WRkZJCSkmJ3fnp6uu0sPTw8vN51OaJPXH3hImKPS4V4nz59WLt2Ldu3b7+i9sOGDSMuLo4tW7bYnX9xevv27et9ZwrUr69LfeEiV5f69om71LtT9u7dy+DBg3F3dycxMZHevXtfsv3u3bsZOnQobm5uJCcn13jgZ9SoUcTFxTFnzhyWLl3agJXXpL5wEbkSLvWwz6BBg7jrrrsoKytj/PjxfPfdd9Xmnzp1ioULF1JYWNW1ERERwbhx4ygvL2fKlCmcPn0agMrKSp5//nni4uLw9vbmySefbNT90NOZInKlXOpMHKoubk6aNMn2+tb27dsTEhJCVlYWGRkZWK1WcnNzCQgIAMBisTBixAiOHz+Ot7c3vXr1Iisri6ysLNzc3Fi5ciV33XVXo+6DzsJF5Eq51Jk4VF3c/Prrr1mxYgXXX389RUVF/PDDD5jNZm688UZWrFiBn5+frX1wcDAJCQnMmzePkJAQDh48SHl5OZMnT2bbtm2NHuAAvs298fL00Fm4iFyWy52Ju4oLJaV4ergrxEXkkhTiIiIG5nLdKSIiVxOFuIiIgSnERUQMTCEuImJgCnEREQNTiIuIGJhCXETEwBTiIiIGphAXETEwhbiIiIEpxEVEDEwhLiJiYApxEREDU4iLiBiYQlxExMAU4iIiBqYQFxExMIW4iIiBKcRFRAxMIS4iYmAKcRERA1OIi4gYmEJcRMTAFOIiIgamEBcRMTCFuIiIgSnERUQMTCEuImJgCnEREQNTiIuIGJhCXETEwBTiIiIGphAXETEwhbiIiIEpxEVEDEwhLiJiYApxEREDU4iLiBiYQlxExMD+P+aIbrtw+y61AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 454.517x284.278 with 1 Axes>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.circuit import ClassicalRegister, QuantumCircuit\n",
    "from qiskit.circuit.library import XXMinusYYGate\n",
    "\n",
    "num_qubits = 2\n",
    "\n",
    "# circuit originally generated by\n",
    "# `random_circuit(num_qubits=num_qubits, depth=3, measure=False, seed=0)`\n",
    "\n",
    "qc_random = QuantumCircuit(2)\n",
    "qc_random.append(XXMinusYYGate(1.7, 0.257), [0, 1])\n",
    "qc_random.rx(5.74, qubit=0)\n",
    "qc_random.id(qubit=1)\n",
    "qc_random.ch(control_qubit=1, target_qubit=0)\n",
    "\n",
    "creg = ClassicalRegister(1)\n",
    "qc_random.add_register(creg)\n",
    "qc_random.draw(\"mpl\", style=\"iqp\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also draw 3 random observables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.quantum_info import SparsePauliOp\n",
    "\n",
    "set_observables = [\n",
    "    SparsePauliOp([\"II\", \"XX\", \"YY\", \"ZY\"], coeffs=[1, 1, -4, 1]),\n",
    "    SparsePauliOp([\"XI\", \"ZX\", \"YI\"], coeffs=[1, -1, 2.5]),\n",
    "    SparsePauliOp([\"II\", \"XI\", \"ZI\", \"IX\", \"IY\", \"YX\"], coeffs=[0.4, 4, -1, 1, -0.5, 1.8]),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For reference, we compute the true final state and the exact expectation values for the different observables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit.quantum_info import Statevector\n",
    "\n",
    "exact_state = Statevector(qc_random)\n",
    "exp_val = np.real_if_close(\n",
    "    np.array([exact_state.expectation_value(obs) for obs in set_observables])\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classical Shadows\n",
    "\n",
    "We now look at the implementation of Classical Shadows measurement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from povm_toolbox.library import ClassicalShadows\n",
    "\n",
    "# By default, the Classical Shadows (CS) measurement uses Z-,X-,Y-measurements with equal probability.\n",
    "cs_implementation = ClassicalShadows(num_qubits=num_qubits, seed=23)\n",
    "# Define the default shot budget.\n",
    "cs_shots = 4096\n",
    "# Construct the `POVMSamplerPub`.\n",
    "cs_pub = (qc_random, None, cs_shots, cs_implementation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Locally-Biased Classical Shadows\n",
    "We now look at Classical Shadows that can be locally-biased."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from povm_toolbox.library import LocallyBiasedClassicalShadows\n",
    "\n",
    "# Set the distributions of the shots among the Z-,X-,Y-measurements (in this order).\n",
    "bias = np.array(\n",
    "    [\n",
    "        [\n",
    "            0.0000000028,  # bias for Z-measurements on first qubit\n",
    "            0.4408677642,  # bias for X-measurements on first qubit\n",
    "            0.5591322330,  # bias for Y-measurements on first qubit\n",
    "        ],\n",
    "        [\n",
    "            0.1989721524,  # bias for Z-measurements on second qubit\n",
    "            0.3190601952,  # bias for X-measurements on second qubit\n",
    "            0.4819676524,  # bias for Y-measurements on second qubit\n",
    "        ],\n",
    "    ]\n",
    ")\n",
    "\n",
    "# The Locally-Biased Classical Shadows (LBCS) measurement uses Z-,X-,Y-measurements with different probabilities.\n",
    "lbcs_implementation = LocallyBiasedClassicalShadows(num_qubits=num_qubits, bias=bias, seed=24)\n",
    "# Define the default shot budget.\n",
    "lbcs_shots = 4096\n",
    "# Construct the `POVMSamplerPub`.\n",
    "lbcs_pub = (qc_random, None, lbcs_shots, lbcs_implementation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mutually-Unbiased-Bases POVM\n",
    "We now look at POVMs that are rotated locally-biased Classical Shadows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from povm_toolbox.library import MutuallyUnbiasedBasesMeasurements\n",
    "\n",
    "# Define the Euler angles to rotate the measurement.\n",
    "angles = np.array(\n",
    "    [\n",
    "        [0.0000027222, 0.0000000910, 0.3],\n",
    "        [0.0000022917, 0.0000002655, 0.0],\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Set the distributions of the shots among the PMs.\n",
    "bias = np.array(\n",
    "    [\n",
    "        [0.0000372719, 0.4377084332, 0.5622542949],\n",
    "        [0.2002136793, 0.3192036469, 0.4805826738],\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Define the PM-simulable POVM.\n",
    "mub_implementation = MutuallyUnbiasedBasesMeasurements(\n",
    "    num_qubits=num_qubits, bias=bias, angles=angles, seed=12\n",
    ")\n",
    "# Define the default shot budget.\n",
    "mub_shots = 4100\n",
    "# Construct the `POVMSamplerPub`.\n",
    "mub_pub = (qc_random, None, mub_shots, mub_implementation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PM-simulable POVM\n",
    "We now look at POVMs that are simulable (through randomization) with only single-qubit projective measurements (PMs)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from povm_toolbox.library import RandomizedProjectiveMeasurements\n",
    "\n",
    "# Define our projective measurements acting on each qubit.\n",
    "angles = np.array(\n",
    "    [\n",
    "        [0.0000027222, 0.0000000910, 1.5707688831, 0.0000235665, 1.5707519773, 1.5707694998],\n",
    "        [0.0000022917, 0.0000002655, 1.5707961328, 0.0000069500, 1.5707958682, 1.5708006931],\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Set the distributions of the shots among the PMs.\n",
    "bias = np.array(\n",
    "    [\n",
    "        [0.0000372719, 0.4377084332, 0.5622542949],\n",
    "        [0.2002136793, 0.3192036469, 0.4805826738],\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Define the PM-simulable POVM.\n",
    "pmsim_implementation = RandomizedProjectiveMeasurements(\n",
    "    num_qubits=num_qubits, bias=bias, angles=angles, seed=25\n",
    ")\n",
    "# Define the default shot budget.\n",
    "pmsim_shots = 4100\n",
    "# Construct the `POVMSamplerPub`.\n",
    "pmsim_pub = (qc_random, None, pmsim_shots, pmsim_implementation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## POVM Sampler\n",
    "\n",
    "We now instantiate the `POVMSampler` that will use the different POVM measurements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import default_rng\n",
    "from povm_toolbox.sampler.povm_sampler import POVMSampler\n",
    "from qiskit.primitives import StatevectorSampler\n",
    "\n",
    "# First define a standard sampler (that will be used under the hood).\n",
    "sampler = StatevectorSampler(seed=default_rng(0))\n",
    "# Then define the POVM sampler, which takes BaseSampler as an argument.\n",
    "povm_sampler = POVMSampler(sampler)\n",
    "# Submit the job by specifying which POVM to use, which circuit(s) to measure and the shot budget.\n",
    "job = povm_sampler.run([cs_pub, lbcs_pub, mub_pub, pmsim_pub])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results\n",
    "We retrieve the result object, which contains the POVM used and from which we can query the counts of each outcome."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--------------------------------------------------------------------------------------\n",
      "\n",
      "PUB number : 0\n",
      "POVM class: ClassicalShadows(num_qubits=2)\n",
      "Number of shots : 4096\n",
      "\n",
      "   Exact         Estimate       Error      Estimated std     z-score\n",
      "    1.470e+00      1.347e+00       8.4%          0.19243       -0.64\n",
      "   -1.420e+00     -1.294e+00       8.8%          0.08414        1.49\n",
      "    2.947e+00      3.072e+00       4.2%          0.12670        0.98\n",
      "\n",
      "--------------------------------------------------------------------------------------\n",
      "\n",
      "PUB number : 1\n",
      "POVM class: LocallyBiasedClassicalShadows(num_qubits=2, bias=array([[2.80000000e-09, 4.40867764e-01, 5.59132233e-01],\n",
      "       [1.98972152e-01, 3.19060195e-01, 4.81967652e-01]]))\n",
      "Number of shots : 4096\n",
      "\n",
      "   Exact         Estimate       Error      Estimated std     z-score\n",
      "    1.470e+00      1.533e+00       4.3%          0.13764        0.46\n",
      "   -1.420e+00     -1.532e+00       7.9%          0.07798       -1.44\n",
      "    2.947e+00      2.920e+00       0.9%          0.11659       -0.24\n",
      "\n",
      "--------------------------------------------------------------------------------------\n",
      "\n",
      "PUB number : 2\n",
      "POVM class: MutuallyUnbiasedBasesMeasurements(num_qubits=2, bias=array([[3.72719000e-05, 4.37708433e-01, 5.62254295e-01],\n",
      "       [2.00213679e-01, 3.19203647e-01, 4.80582674e-01]]), angles=array([[2.7222e-06, 9.1000e-08, 3.0000e-01],\n",
      "       [2.2917e-06, 2.6550e-07, 0.0000e+00]]))\n",
      "Number of shots : 4100\n",
      "\n",
      "   Exact         Estimate       Error      Estimated std     z-score\n",
      "    1.470e+00      1.495e+00       1.7%          0.13698        0.18\n",
      "   -1.420e+00     -1.497e+00       5.5%          0.07997       -0.97\n",
      "    2.947e+00      2.826e+00       4.1%          0.11678       -1.04\n",
      "\n",
      "--------------------------------------------------------------------------------------\n",
      "\n",
      "PUB number : 3\n",
      "POVM class: RandomizedProjectiveMeasurements(num_qubits=2, bias=array([[3.72719000e-05, 4.37708433e-01, 5.62254295e-01],\n",
      "       [2.00213679e-01, 3.19203647e-01, 4.80582674e-01]]), angles=array([[[2.72220000e-06, 9.10000000e-08],\n",
      "        [1.57076888e+00, 2.35665000e-05],\n",
      "        [1.57075198e+00, 1.57076950e+00]],\n",
      "\n",
      "       [[2.29170000e-06, 2.65500000e-07],\n",
      "        [1.57079613e+00, 6.95000000e-06],\n",
      "        [1.57079587e+00, 1.57080069e+00]]]))\n",
      "Number of shots : 4100\n",
      "\n",
      "   Exact         Estimate       Error      Estimated std     z-score\n",
      "    1.470e+00      1.521e+00       3.4%          0.13332        0.38\n",
      "   -1.420e+00     -1.495e+00       5.3%          0.07798       -0.97\n",
      "    2.947e+00      3.054e+00       3.6%          0.11699        0.91\n",
      "\n",
      "--------------------------------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from povm_toolbox.post_processor.povm_post_processor import POVMPostProcessor\n",
    "\n",
    "# Retrieve the `PrimitiveResult` object, which contains 3 `POVMPubResult` objects.\n",
    "result = job.result()\n",
    "print(f\"\\n{'-':-<85}-\\n\")\n",
    "\n",
    "# Loop through the different PUB results\n",
    "for k, pub_result in enumerate(result):\n",
    "    # Instantiate the post-processor from the PUB result.\n",
    "    post_processor = POVMPostProcessor(pub_result)\n",
    "    print(f\"PUB number : {k}\")\n",
    "    # If one wants to explicitly retrieve the POVM used for a specific PUB,\n",
    "    # it can be accessed through the metadata of the PUB result.\n",
    "    print(f\"POVM class: {pub_result.metadata.povm_implementation}\")\n",
    "    print(f\"Number of shots : {sum(post_processor.counts[0].values())}\\n\")\n",
    "\n",
    "    print(\"   Exact         Estimate       Error      Estimated std     z-score\")\n",
    "    for i, obs in enumerate(set_observables):\n",
    "        cs_est_exp_val, std = post_processor.get_expectation_value(obs)\n",
    "        print(\n",
    "            f\"   {np.real(exp_val[i]):>10.3e}   {cs_est_exp_val:>12.3e}   {abs(cs_est_exp_val - np.real(exp_val[i])) / abs(np.real(exp_val[i])):>8.1%}\",\n",
    "            end=\" \",\n",
    "        )\n",
    "        print(f\"        {std:> 8.5f} {(cs_est_exp_val - np.real(exp_val[i])) / std:> 11.2f}\")\n",
    "    print(f\"\\n{'-':-<85}-\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1630.58x367.889 with 1 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Inspect one of the circuit sent to the internal `BaseSamplerV2` sampler:\n",
    "\n",
    "lbcs_composed_circuit = result[1].metadata.composed_circuit\n",
    "lbcs_composed_circuit.draw(\"mpl\", style=\"iqp\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}