examples/braket_features/Noise_models/Noise_models_on_Rigetti.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "74154c03-d48f-4f41-867b-5e30254ce31a",
   "metadata": {},
   "source": [
    "# Noise models on Rigetti\n",
    "\n",
    "This notebook shows how to construct a noise model from device calibration data for Rigetti Ankaa-2. We compare the measurement outcomes of circuits run on a noisy simulator with the same circuits run on quantum processing units (QPUs), to show that simulating circuits with noise models more closely mimics QPUs.\n",
    "\n",
    "**Before you begin**: We recommend being familiar with [Noise models on Amazon Braket.](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/braket_features/Noise_models/Noise_models_on_Amazon_Braket.ipynb)\n",
    "Additionally, users should be familiar with [Running quantum circuits on QPU devices](https://github.com/amazon-braket/amazon-braket-examples/blob/main/examples/getting_started/2_Running_quantum_circuits_on_QPU_devices/2_Running_quantum_circuits_on_QPU_devices.ipynb). \n",
    "\n",
    "### Table of Contents\n",
    "\n",
    "- Noise model for Rigetti\n",
    "  - Loading device calibration data\n",
    "  - Comparing noisy simulator results to QPU results\n",
    "  - Smaller noise models compared to QPU results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e5e15fcd-55a2-4168-acc6-a38100f94511",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from braket.aws import AwsDevice\n",
    "from braket.circuits import Circuit, Gate\n",
    "from braket.circuits.noise_model import GateCriteria, NoiseModel, ObservableCriteria\n",
    "from braket.circuits.noises import (\n",
    "    BitFlip,\n",
    "    Depolarizing,\n",
    "    TwoQubitDepolarizing,\n",
    ")\n",
    "from braket.devices import Devices, LocalSimulator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4da3e37-e93c-4273-98bc-d67b26b8c822",
   "metadata": {},
   "source": [
    "Braket provides access to hardware providers' reported calibration data. \n",
    "This can be used to construct noise models to approximate the behavior of the QPU when running circuits on a noisy simulator.\n",
    "In this tutorial, we focus on local noise models with no crosstalk interactions. Real devices can have crosstalk and unexpected effects that can further degrade the results.\n",
    "\n",
    "The Ankaa-2 calibration data is available on the Braket devices page. Under qubit specs, the calibration data include the qubit index, with corresponding values for the $T_1$, $T_2$, fidelity from randomized benchmarking (fRB),  fidelity from simultaneous randomized benchmarking (fsRB), and readout fidelity (fRO).\n",
    "Under \"edge specs\", the data includes the RB fidelity for two qubit gates for each connected edge in the device topology."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38001b96-faf7-49f0-b5a5-2d52820fcfc9",
   "metadata": {},
   "source": [
    "**One-qubit calibration data (Qubit specs)**\n",
    "<div align=center><img src=\"ankaa2_qubit_specs.png\"/></div>\n",
    "\n",
    "\n",
    "**Two-qubit calibration data (Edge specs)**\n",
    "<div align=center><img src=\"ankaa2_edge_specs.png\"/></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "276d680f-887d-4929-bcaa-e276a6303496",
   "metadata": {},
   "source": [
    "We can programmatically access all the calibration data with the Braket SDK. First we load the AwsDevice using the ARN for Rigetti Ankaa-2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a55ea9d5-05f3-4da5-a305-a391e914d012",
   "metadata": {},
   "outputs": [],
   "source": [
    "rigetti = AwsDevice(Devices.Rigetti.Ankaa2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66d8f3bf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a8a42ae1-51ac-4bf1-bd6a-81ffd982b5f8",
   "metadata": {},
   "source": [
    "The properties dictionary contains one- and two-qubit calibration data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "153b5b63-8205-4a7e-bb18-0305ef428f36",
   "metadata": {},
   "outputs": [],
   "source": [
    "one_qubit_data = rigetti.properties.standardized.oneQubitProperties\n",
    "two_qubit_data = rigetti.properties.standardized.twoQubitProperties"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "661cca17-01fa-40be-bd3e-741bacc74ce4",
   "metadata": {},
   "source": [
    "For Ankaa-2, we can get all qubit indices with `one_qubit_data.keys()` or with `rigetti.topology_graph.nodes`.\n",
    "\n",
    "The keys of the two qubit dictionary are the connected qubit pairs separated by a hyphen. \n",
    "For example, if qubit 0 and 1 are connected the key is \"0-1\".\n",
    "\n",
    "\n",
    "#### One-qubit noise \n",
    "\n",
    "Let's look at the one qubit calibration data for qubit 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8d4ecc35-f4dc-49d8-b6ff-adaee560ac4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OneQubitProperties(T1=CoherenceTime(value=8.645474408067754e-06, standardError=None, unit='S'), T2=CoherenceTime(value=1.2710111632672265e-05, standardError=None, unit='S'), oneQubitFidelity=[Fidelity1Q(fidelityType=FidelityType(name='RANDOMIZED_BENCHMARKING', description=None), fidelity=0.998913376867117, standardError=2.7016428586132974e-05), Fidelity1Q(fidelityType=FidelityType(name='SIMULTANEOUS_RANDOMIZED_BENCHMARKING', description=None), fidelity=0.9975435377199546, standardError=0.00015343141167926104), Fidelity1Q(fidelityType=FidelityType(name='READOUT', description=None), fidelity=0.9219999999999999, standardError=None)])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_qubit_data[\"0\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b676762-e642-4a98-89e3-86d79367071a",
   "metadata": {},
   "source": [
    "For each qubit, there are various metrics of the quality:\n",
    "\n",
    "- **T1**: Thermal relaxation time is related to the time it takes for the excited state, |1⟩, to decay into the ground state, |0⟩. The probability of remaining in the excited state is $p(|1⟩)\\sim e^{-t/T_1}$\n",
    "\n",
    "- **T2**: The dephasing time, is the decay constant for the scale for a |+⟩ state to decohere into the completely mixed state. $p(|+⟩)\\sim e^{-t/T_2}$ \n",
    "\n",
    "- **Fidelity (RB)**: Single-qubit randomized benchmarking fidelities. RB fidelity quantifies the average gate fidelity where the average is over all Clifford gates. RB describes an *effective* noise model with gate-independent depolarizing noise on each Clifford gate.\n",
    "\n",
    "- **Fidelity (sRB)**: Single-qubit simultaneous randomized benchmarking fidelities. These are extracted by running single-qubit RB on all qubits simultaneously. Note that we expect the sRB fidelity to be lower than standard RB fidelity due to non-local crosstalk type noise on the device. \n",
    "\n",
    "- **Readout fidelity**: Single-qubit readout fidelities describes the probability of a bit flip error before readout in the computational basis. The readout fidelity is related to the probability of correctly measuring the ground state and excited states respectively, e.g. $f_{RO} =\\frac{p(0|0)+p(1|1)}{2}$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "296708a3-771e-42b4-9ba8-f3db1a02970b",
   "metadata": {},
   "source": [
    "Now that we know how to extract and use the calibration data, we can build a simple noise model. For every qubit we will add:\n",
    "- amplitude dampening noise with probability $p= 1-e^{-t/T_1}$ for every gate\n",
    "- phase dampening noise with probability $p= 0.5(1-e^{-t/T_2})$ for every gate\n",
    "- depolarizing noise with probability $p=1-f_{sRB}$ (from simultaneous RB fidelity) for  every gate\n",
    "- readout bit flip noise with probability $p=1-f_{RO}$ to measurements \n",
    "\n",
    "Technically, the sRB fidelity already includes effects from $T_1$/$T_2$, however to be explicit we add these as separate terms. In a sense, this model might overestimate the noise on the QPU.  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5769f2f4-de1c-4b47-9e4e-fd8d39b9e975",
   "metadata": {},
   "source": [
    "To create the noise model, we iterate over all qubits keys in `one_qubit_data`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7442cd27",
   "metadata": {},
   "outputs": [],
   "source": [
    "noise_model = NoiseModel()\n",
    "\n",
    "# Readout Noise Model\n",
    "for q, data in rigetti.properties.standardized.oneQubitProperties.items():\n",
    "    try:\n",
    "        readout_error = 1 - data.oneQubitFidelity[2].fidelity  # readout\n",
    "        noise_model.add_noise(BitFlip(readout_error), ObservableCriteria(qubits=int(q)))\n",
    "\n",
    "        depolarizing_rate = (\n",
    "            1 - data.oneQubitFidelity[1].fidelity\n",
    "        )  # SIMULTANEOUS_RANDOMIZED_BENCHMARKING\n",
    "        noise_model.add_noise(Depolarizing(probability=depolarizing_rate), GateCriteria(qubits=q))\n",
    "    except:  # noqa: PERF203\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9d20d24c-17e2-4bba-b317-fb2d156bedb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of terms in noise model is: 167\n",
      "Number of parameters in noise model is: 167\n"
     ]
    }
   ],
   "source": [
    "num_params = sum(len(item.noise.parameters) for item in noise_model.instructions)\n",
    "print(f\"Number of terms in noise model is: {len(noise_model.instructions)}\")\n",
    "print(f\"Number of parameters in noise model is: {num_params}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "790c62f7-776a-4e4c-9405-7b7a14eee5b0",
   "metadata": {},
   "source": [
    "#### Two-qubit noise \n",
    "Next we consider adding two-qubit noise to the model. \n",
    "\n",
    "Let's first look at the data provided in the Ankaa-2 device calibration data. On the first connect, \"0-1\", the properties are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "626cbe56-3649-48eb-a2a1-f669eb790b47",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TwoQubitProperties(twoQubitGateFidelity=[GateFidelity2Q(direction=None, gateName='ISWAP', fidelity=0.9773180863130815, standardError=0.00408287380553746, fidelityType=FidelityType(name='INTERLEAVED_RANDOMIZED_BENCHMARKING', description=None))])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "two_qubit_data[\"0-1\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bcd3be4-a6e4-4cf3-841e-1a451e01803a",
   "metadata": {},
   "source": [
    "Here, we see the fidelity per gate (ISWAP or CZ) and the associated standard error. \n",
    "\n",
    "Next we loop over the entries in the `two_qubit_data` dictionary and add two-qubit depolarizing noise to the model. Notice that Ankaa-2 has symmetric connections (\"0-1\" and \"1-0\") so we need to add noise in both directions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "80f57550-6549-46b6-9a6d-ff7f0f03e90d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Two-qubit noise\n",
    "for pair, data in two_qubit_data.items():  # iterate over qubit connections\n",
    "    # parse strings \"0-1\" to integers [0, 1]\n",
    "    q0, q1 = (int(s) for s in pair.split(\"-\"))\n",
    "    try:\n",
    "        if data.twoQubitGateFidelity[0].gateName == \"ISWAP\":\n",
    "            phase_rate = 1 - data.twoQubitGateFidelity[0].fidelity\n",
    "            noise_model.add_noise(\n",
    "                TwoQubitDepolarizing(phase_rate),\n",
    "                GateCriteria(Gate.ISwap, [(q0, q1), (q1, q0)]),  # symmetric connections\n",
    "            )\n",
    "    except:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "82376d08-84bc-4249-9c8d-d7aacdb73113",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of terms in noise model is: 274\n",
      "Number of parameters in noise model is: 274\n"
     ]
    }
   ],
   "source": [
    "num_params = sum(len(item.noise.parameters) for item in noise_model.instructions)\n",
    "print(f\"Number of terms in noise model is: {len(noise_model.instructions)}\")\n",
    "print(f\"Number of parameters in noise model is: {num_params}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5913a8a2-a9de-4e32-a35d-c48191891b1f",
   "metadata": {},
   "source": [
    "### Compare circuits run on device vs simulator with a noise model\n",
    "\n",
    "Let's just look at the first 5 qubits. Note that to ensure the noise model applied T1 and T2 noise during the time between gate, we manually add identity gates to each moment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6fabbd05-b480-43c6-b43a-d396d81bd687",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │     0      │     1      │    2    │\n",
      "      ┌──────────┐ ┌──────────┐ ┌───────┐ \n",
      "q0 : ─┤ Rx(0.50) ├─┤ Rx(3.14) ├─┤ ISWAP ├─\n",
      "      └──────────┘ └──────────┘ └───┬───┘ \n",
      "      ┌──────────┐ ┌──────────┐ ┌───┴───┐ \n",
      "q1 : ─┤ Rz(0.50) ├─┤ Rx(3.14) ├─┤ ISWAP ├─\n",
      "      └──────────┘ └──────────┘ └───────┘ \n",
      "      ┌──────────┐ ┌──────────┐           \n",
      "q2 : ─┤ Rz(0.50) ├─┤ Rx(3.14) ├───────────\n",
      "      └──────────┘ └──────────┘           \n",
      "T  : │     0      │     1      │    2    │\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(42)\n",
    "\n",
    "circ = Circuit().rx(0, 0.5).rz(1, 0.5).rz(2, 0.5).rx(0, np.pi).rx(1, np.pi).rx(2, np.pi).iswap(0, 1)\n",
    "print(circ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e2af07ed-33de-4709-9e7c-5e3c3caaa751",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │     0      │     1      │            2            │\n",
      "      ┌──────────┐ ┌──────────┐ ┌───────┐ ┌─────────────┐ \n",
      "q0 : ─┤ Rx(0.50) ├─┤ Rx(3.14) ├─┤ ISWAP ├─┤ DEPO(0.023) ├─\n",
      "      └──────────┘ └──────────┘ └───┬───┘ └──────┬──────┘ \n",
      "      ┌──────────┐ ┌──────────┐ ┌───┴───┐ ┌──────┴──────┐ \n",
      "q1 : ─┤ Rz(0.50) ├─┤ Rx(3.14) ├─┤ ISWAP ├─┤ DEPO(0.023) ├─\n",
      "      └──────────┘ └──────────┘ └───────┘ └─────────────┘ \n",
      "      ┌──────────┐ ┌──────────┐                           \n",
      "q2 : ─┤ Rz(0.50) ├─┤ Rx(3.14) ├───────────────────────────\n",
      "      └──────────┘ └──────────┘                           \n",
      "T  : │     0      │     1      │            2            │\n"
     ]
    }
   ],
   "source": [
    "noisy_circ = noise_model.apply(circ)\n",
    "\n",
    "print(noisy_circ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9304dcf1-a1e8-4e41-a6b5-769841f4eefe",
   "metadata": {},
   "outputs": [],
   "source": [
    "simulator = LocalSimulator()  # noise free simulator\n",
    "task = simulator.run(circ, shots=10_000)\n",
    "free_probs = task.result().measurement_probabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0e1d9cfe-03d6-406b-b4ab-89166a907681",
   "metadata": {},
   "outputs": [],
   "source": [
    "noisy_simulator = LocalSimulator(\"braket_dm\")\n",
    "noisy_task = noisy_simulator.run(noisy_circ, shots=10_000)\n",
    "noisy_probs = noisy_task.result().measurement_probabilities"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3f370bd-a8b3-4d5b-a724-da549fc4c81f",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> The below section runs tasks on the Rigetti Ankaa-2 device. When you run this notebook, make sure the device is currently available. You can find QPU availability windows on the <a href=\"https://us-west-1.console.aws.amazon.com/braket/home?region=us-west-1#/devices\">Devices page</a> in the Amazon Braket Console.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note:</b> Running the circuit below will result in charges on your AWS account.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c8f4664a-0527-46fb-87f2-2a0c85f0bd79",
   "metadata": {},
   "outputs": [],
   "source": [
    "rigetti_task = rigetti.run(circ, shots=10_000, disable_qubit_rewiring=True)\n",
    "rigetti_result = rigetti_task.result()\n",
    "rigetti_probs = rigetti_result.measurement_probabilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1676a45c-5ef8-49cc-b227-69f69fa2004a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Ankaa-2</th>\n",
       "      <th>noisy_sim</th>\n",
       "      <th>free_sim</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>110</th>\n",
       "      <td>0.1866</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>011</th>\n",
       "      <td>0.0996</td>\n",
       "      <td>0.0061</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>001</th>\n",
       "      <td>0.0528</td>\n",
       "      <td>0.0055</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>111</th>\n",
       "      <td>0.4555</td>\n",
       "      <td>0.9214</td>\n",
       "      <td>0.9384</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>101</th>\n",
       "      <td>0.1254</td>\n",
       "      <td>0.0670</td>\n",
       "      <td>0.0616</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>010</th>\n",
       "      <td>0.0229</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>100</th>\n",
       "      <td>0.0443</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000</th>\n",
       "      <td>0.0129</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Ankaa-2  noisy_sim  free_sim\n",
       "110   0.1866        NaN       NaN\n",
       "011   0.0996     0.0061       NaN\n",
       "001   0.0528     0.0055       NaN\n",
       "111   0.4555     0.9214    0.9384\n",
       "101   0.1254     0.0670    0.0616\n",
       "010   0.0229        NaN       NaN\n",
       "100   0.0443        NaN       NaN\n",
       "000   0.0129        NaN       NaN"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "free_sim = pd.DataFrame.from_dict(free_probs, orient=\"index\").rename(columns={0: \"free_sim\"})\n",
    "noisy_sim = pd.DataFrame.from_dict(noisy_probs, orient=\"index\").rename(columns={0: \"noisy_sim\"})\n",
    "Ankaa = pd.DataFrame.from_dict(rigetti_probs, orient=\"index\").rename(columns={0: \"Ankaa-2\"})\n",
    "df = Ankaa.join(noisy_sim).join(free_sim)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "472e6850-2603-4174-bf92-b04eb0c38c2f",
   "metadata": {},
   "source": [
    "We can compute the fidelity between the free simulation and Rigetti, as well as the noisy simulation and Rigetti. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5b7d1740-cb46-433e-8c2b-7e8b7c10fb4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Total fidelity between Ankaa-2 and noise-free simulator is 0.7416798056649024\n",
      "\n",
      "Total fidelity between Ankaa-2 and noisy simulator is 0.7811919904651835\n"
     ]
    }
   ],
   "source": [
    "def fidelity(p, q):\n",
    "    return np.sum(np.sqrt(p * q))\n",
    "\n",
    "\n",
    "f_free_Ankaa = fidelity(df[\"free_sim\"], df[\"Ankaa-2\"])\n",
    "f_noisy_Ankaa = fidelity(df[\"noisy_sim\"], df[\"Ankaa-2\"])\n",
    "\n",
    "print(f\"\\nTotal fidelity between Ankaa-2 and noise-free simulator is {f_free_Ankaa}\")\n",
    "print(f\"\\nTotal fidelity between Ankaa-2 and noisy simulator is {f_noisy_Ankaa}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd4d88b7-015e-445b-ba26-1bdbc6a2bd16",
   "metadata": {},
   "source": [
    "To better visualize, we can also plot the output probability distributions from each circuit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9329ed72-2f30-4383-b48f-0d50e1a5dd11",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "df.plot.bar(\n",
    "    title=\"Comparing noise-free simulator, noisy simulator, and Ankaa-2\",\n",
    "    figsize=(12, 6),\n",
    ")\n",
    "\n",
    "text = f\"f_free_Ankaa = {f_free_Ankaa:.3f} \\nf_noise_model_Ankaa = {f_noisy_Ankaa:.3f}\"\n",
    "plt.text(1, 0.5, text, fontsize=14)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa8ffab8-e062-4c33-9c9d-4a312cd76b63",
   "metadata": {},
   "source": [
    "We confirm that the simulator with a noise model is closer to the distribution produced by Ankaa-2."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4571a5e-2f8d-4767-b28e-a527d2490830",
   "metadata": {},
   "source": [
    "### Smaller, reduced noise models\n",
    "\n",
    "The full Rigetti Ankaa-2 noise model contains due to non-uniform qubit noise. We can obtain simpler, smaller noise models by coarse graining the model above.\n",
    "\n",
    "Here, we consider taking the average over all qubits for the $T_1$, $T_2$, depolarizing, and readout depolarizing rates. This is a substantially smaller noise model, but may be less accurate. \n",
    "\n",
    "We use the `from_filter` function to extract all instructions with amplitude dampening noise in the model. We then compute the mean of the error probabilities. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "eac8479f-4b29-42d8-a15a-ba10aae82d3f",
   "metadata": {},
   "outputs": [],
   "source": [
    "avg_depo = np.mean(\n",
    "    [n.noise.parameters for n in noise_model.from_filter(noise=Depolarizing).instructions]\n",
    ")\n",
    "avg_readout = np.mean(\n",
    "    [n.noise.parameters for n in noise_model.from_filter(noise=BitFlip).instructions]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1a64cae-226c-45d2-9af3-4b5b7a36c7a4",
   "metadata": {},
   "source": [
    "Now we construct a new noise model with the mean values above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e49eb24c-5f24-4084-9d4c-c2e7e82fc259",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gate Noise:\n",
      "  Depolarizing(0.010099107504894678), GateCriteria(None, None)\n",
      "Readout Noise:\n",
      "  BitFlip(0.06397619047619048), ObservableCriteria(None, None)\n"
     ]
    }
   ],
   "source": [
    "simple_noise_model = NoiseModel()\n",
    "simple_noise_model.add_noise(Depolarizing(avg_depo), GateCriteria())\n",
    "simple_noise_model.add_noise(BitFlip(avg_readout), ObservableCriteria())\n",
    "\n",
    "print(simple_noise_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b44bbbd1-fb65-4b8f-8dfa-0ea5aa7979b2",
   "metadata": {},
   "source": [
    "We can see the resultant circuits contain qubit-independent noise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c83e96f6-54b0-445b-bcdd-8a7a16691b62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "T  : │             0             │             1             │           2            │\n",
      "      ┌──────────┐ ┌────────────┐ ┌──────────┐ ┌────────────┐ ┌───────┐ ┌────────────┐ \n",
      "q0 : ─┤ Rx(0.50) ├─┤ DEPO(0.01) ├─┤ Rx(3.14) ├─┤ DEPO(0.01) ├─┤ ISWAP ├─┤ DEPO(0.01) ├─\n",
      "      └──────────┘ └────────────┘ └──────────┘ └────────────┘ └───┬───┘ └────────────┘ \n",
      "      ┌──────────┐ ┌────────────┐ ┌──────────┐ ┌────────────┐ ┌───┴───┐ ┌────────────┐ \n",
      "q1 : ─┤ Rz(0.50) ├─┤ DEPO(0.01) ├─┤ Rx(3.14) ├─┤ DEPO(0.01) ├─┤ ISWAP ├─┤ DEPO(0.01) ├─\n",
      "      └──────────┘ └────────────┘ └──────────┘ └────────────┘ └───────┘ └────────────┘ \n",
      "      ┌──────────┐ ┌────────────┐ ┌──────────┐ ┌────────────┐                          \n",
      "q2 : ─┤ Rz(0.50) ├─┤ DEPO(0.01) ├─┤ Rx(3.14) ├─┤ DEPO(0.01) ├──────────────────────────\n",
      "      └──────────┘ └────────────┘ └──────────┘ └────────────┘                          \n",
      "T  : │             0             │             1             │           2            │\n"
     ]
    }
   ],
   "source": [
    "simple_noisy_circ = simple_noise_model.apply(circ)\n",
    "print(simple_noisy_circ)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2c20b79-cbf2-4897-80b3-452c78d56a03",
   "metadata": {},
   "source": [
    "We run the circuit on a noisy simulator below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a1bb19e8-6824-4a50-b9fb-ae06c14359b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "simple_noisy_task = noisy_simulator.run(simple_noisy_circ, shots=100_000)\n",
    "simple_noisy_probs = simple_noisy_task.result().measurement_probabilities"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76418e5c-be5b-4b3a-8916-c0f56f003cd7",
   "metadata": {},
   "source": [
    "and add it to the previous dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b4d27a95-612d-4dea-9f6a-98d4525b0a70",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Ankaa-2</th>\n",
       "      <th>noisy_sim</th>\n",
       "      <th>free_sim</th>\n",
       "      <th>simple_noisy_sim</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>110</th>\n",
       "      <td>0.1866</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.01230</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>011</th>\n",
       "      <td>0.0996</td>\n",
       "      <td>0.0061</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.01795</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>001</th>\n",
       "      <td>0.0528</td>\n",
       "      <td>0.0055</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00156</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>111</th>\n",
       "      <td>0.4555</td>\n",
       "      <td>0.9214</td>\n",
       "      <td>0.9384</td>\n",
       "      <td>0.89030</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>101</th>\n",
       "      <td>0.1254</td>\n",
       "      <td>0.0670</td>\n",
       "      <td>0.0616</td>\n",
       "      <td>0.07659</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>010</th>\n",
       "      <td>0.0229</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00019</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>100</th>\n",
       "      <td>0.0443</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00108</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000</th>\n",
       "      <td>0.0129</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00003</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Ankaa-2  noisy_sim  free_sim  simple_noisy_sim\n",
       "110   0.1866        NaN       NaN           0.01230\n",
       "011   0.0996     0.0061       NaN           0.01795\n",
       "001   0.0528     0.0055       NaN           0.00156\n",
       "111   0.4555     0.9214    0.9384           0.89030\n",
       "101   0.1254     0.0670    0.0616           0.07659\n",
       "010   0.0229        NaN       NaN           0.00019\n",
       "100   0.0443        NaN       NaN           0.00108\n",
       "000   0.0129        NaN       NaN           0.00003"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simple_noisy_sim = pd.DataFrame.from_dict(simple_noisy_probs, orient=\"index\").rename(\n",
    "    columns={0: \"simple_noisy_sim\"}\n",
    ")\n",
    "df = df.join(simple_noisy_sim)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1699bc2-712f-4a99-b9d6-0a0920114a13",
   "metadata": {},
   "source": [
    "We compute the fidelity between the simple noise model and the QPU:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d7710e0b-29ac-4968-aa00-e23cb8b32269",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Total fidelity between Ankaa-2 and full noise model is: 0.7811919904651835\n",
      "\n",
      "Total fidelity between Ankaa-2 and simple noise model is: 0.8437069124308016\n",
      "\n",
      "Total fidelity between Ankaa-2 and noise-free is: 0.7416798056649024\n"
     ]
    }
   ],
   "source": [
    "f_simple = fidelity(df[\"simple_noisy_sim\"], df[\"Ankaa-2\"])\n",
    "\n",
    "print(f\"\\nTotal fidelity between Ankaa-2 and full noise model is: {f_noisy_Ankaa}\")\n",
    "print(f\"\\nTotal fidelity between Ankaa-2 and simple noise model is: {f_simple}\")\n",
    "print(f\"\\nTotal fidelity between Ankaa-2 and noise-free is: {f_free_Ankaa}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "e36e19d0-664a-4cb4-a2e3-0061cd60a6c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.plot.bar(title=\"Comparing simulators and Ankaa-2\", figsize=(12, 6))\n",
    "text = f\"f_free = {f_free_Ankaa:.3f} \\nf_simple_noise_model = {f_simple:.3f} \\nf_noise_model = {f_noisy_Ankaa:.3f}\"\n",
    "plt.text(1, 0.5, text, fontsize=14)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6da72e22-a594-41e7-a4e2-cb82cfe0726a",
   "metadata": {},
   "source": [
    "We see that compared to the full noise model, the simple model is less accurate, however, it is still a significant improvement over the noise-free case and has far fewer parameters in the model. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2c6b2ba-cb54-43f6-9a89-e29066b5192a",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "In this notebook, we showed how to construct a noise model for Rigetti Ankaa-2 based only on the available calibration data.\n",
    "We used a coarse assumption of gate-independent single-qubit depolarizing noise and gate-dependant two-qubit noise. Our qubit-dependent model could be improved in many ways. We could add gate-dependence noise, or change the depolarizing channel to Pauli channels. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98989c13",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "braket",
   "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.10.10"
  },
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false,
  "toc-showtags": true
 },
 "nbformat": 4,
 "nbformat_minor": 5
}