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-3. 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": "e75bd074",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n",
    "from braket.tracking import Tracker\n",
    "\n",
    "t = Tracker().start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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-3 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=\"ankaa3_qubit_specs.png\"/></div>\n",
    "\n",
    "\n",
    "**Two-qubit calibration data (Edge specs)**\n",
    "<div align=center><img src=\"ankaa3_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-3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a55ea9d5-05f3-4da5-a305-a391e914d012",
   "metadata": {},
   "outputs": [],
   "source": [
    "rigetti = AwsDevice(Devices.Rigetti.Ankaa3)"
   ]
  },
  {
   "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": 4,
   "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-3, 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=2.4725305488621275e-05, standardError=None, unit='S'), T2=CoherenceTime(value=4.171429853257298e-05, standardError=None, unit='S'), oneQubitFidelity=[Fidelity1Q(fidelityType=FidelityType(name='RANDOMIZED_BENCHMARKING', description=None), fidelity=0.999653394406776, standardError=2.2840551004503385e-05), Fidelity1Q(fidelityType=FidelityType(name='SIMULTANEOUS_RANDOMIZED_BENCHMARKING', description=None), fidelity=0.999503753863059, standardError=2.2883499186569214e-05), Fidelity1Q(fidelityType=FidelityType(name='READOUT', description=None), fidelity=0.966, 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: 164\n",
      "Number of parameters in noise model is: 164\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-3 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.969786574501804, standardError=0.00289362740474668, 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) 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-3 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: 302\n",
      "Number of parameters in noise model is: 302\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.03) ├─\n",
      "      └──────────┘ └──────────┘ └───┬───┘ └─────┬──────┘ \n",
      "      ┌──────────┐ ┌──────────┐ ┌───┴───┐ ┌─────┴──────┐ \n",
      "q1 : ─┤ Rz(0.50) ├─┤ Rx(3.14) ├─┤ ISWAP ├─┤ DEPO(0.03) ├─\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-3 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-3</th>\n",
       "      <th>noisy_sim</th>\n",
       "      <th>free_sim</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>111</th>\n",
       "      <td>0.6323</td>\n",
       "      <td>0.9165</td>\n",
       "      <td>0.9384</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>011</th>\n",
       "      <td>0.1023</td>\n",
       "      <td>0.0083</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>101</th>\n",
       "      <td>0.1512</td>\n",
       "      <td>0.0680</td>\n",
       "      <td>0.0616</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>100</th>\n",
       "      <td>0.0091</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>001</th>\n",
       "      <td>0.0617</td>\n",
       "      <td>0.0072</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>110</th>\n",
       "      <td>0.0368</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>010</th>\n",
       "      <td>0.0047</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000</th>\n",
       "      <td>0.0019</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Ankaa-3  noisy_sim  free_sim\n",
       "111   0.6323     0.9165    0.9384\n",
       "011   0.1023     0.0083       NaN\n",
       "101   0.1512     0.0680    0.0616\n",
       "100   0.0091        NaN       NaN\n",
       "001   0.0617     0.0072       NaN\n",
       "110   0.0368        NaN       NaN\n",
       "010   0.0047        NaN       NaN\n",
       "000   0.0019        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-3\"})\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-3 and noise-free simulator is 0.8668010125433862\n",
      "\n",
      "Total fidelity between Ankaa-3 and noisy simulator is 0.9128652867740783\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-3\"])\n",
    "f_noisy_Ankaa = fidelity(df[\"noisy_sim\"], df[\"Ankaa-3\"])\n",
    "\n",
    "print(f\"\\nTotal fidelity between Ankaa-3 and noise-free simulator is {f_free_Ankaa}\")\n",
    "print(f\"\\nTotal fidelity between Ankaa-3 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-3\",\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-3."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4571a5e-2f8d-4767-b28e-a527d2490830",
   "metadata": {},
   "source": [
    "### Smaller, reduced noise models\n",
    "\n",
    "The full Rigetti Ankaa-3 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.0042202689661948005), GateCriteria(None, None)\n",
      "Readout Noise:\n",
      "  BitFlip(0.05952439024390244), 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.0042) ├─┤ Rx(3.14) ├─┤ DEPO(0.0042) ├─┤ ISWAP ├─┤ DEPO(0.0042) ├─\n",
      "      └──────────┘ └──────────────┘ └──────────┘ └──────────────┘ └───┬───┘ └──────────────┘ \n",
      "      ┌──────────┐ ┌──────────────┐ ┌──────────┐ ┌──────────────┐ ┌───┴───┐ ┌──────────────┐ \n",
      "q1 : ─┤ Rz(0.50) ├─┤ DEPO(0.0042) ├─┤ Rx(3.14) ├─┤ DEPO(0.0042) ├─┤ ISWAP ├─┤ DEPO(0.0042) ├─\n",
      "      └──────────┘ └──────────────┘ └──────────┘ └──────────────┘ └───────┘ └──────────────┘ \n",
      "      ┌──────────┐ ┌──────────────┐ ┌──────────┐ ┌──────────────┐                            \n",
      "q2 : ─┤ Rz(0.50) ├─┤ DEPO(0.0042) ├─┤ Rx(3.14) ├─┤ DEPO(0.0042) ├────────────────────────────\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-3</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>111</th>\n",
       "      <td>0.6323</td>\n",
       "      <td>0.9165</td>\n",
       "      <td>0.9384</td>\n",
       "      <td>0.91803</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>011</th>\n",
       "      <td>0.1023</td>\n",
       "      <td>0.0083</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00772</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>101</th>\n",
       "      <td>0.1512</td>\n",
       "      <td>0.0680</td>\n",
       "      <td>0.0616</td>\n",
       "      <td>0.06817</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>100</th>\n",
       "      <td>0.0091</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00028</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>001</th>\n",
       "      <td>0.0617</td>\n",
       "      <td>0.0072</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00061</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>110</th>\n",
       "      <td>0.0368</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00516</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>010</th>\n",
       "      <td>0.0047</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.00003</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000</th>\n",
       "      <td>0.0019</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     Ankaa-3  noisy_sim  free_sim  simple_noisy_sim\n",
       "111   0.6323     0.9165    0.9384           0.91803\n",
       "011   0.1023     0.0083       NaN           0.00772\n",
       "101   0.1512     0.0680    0.0616           0.06817\n",
       "100   0.0091        NaN       NaN           0.00028\n",
       "001   0.0617     0.0072       NaN           0.00061\n",
       "110   0.0368        NaN       NaN           0.00516\n",
       "010   0.0047        NaN       NaN           0.00003\n",
       "000   0.0019        NaN       NaN               NaN"
      ]
     },
     "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-3 and full noise model is: 0.9128652867740783\n",
      "\n",
      "Total fidelity between Ankaa-3 and simple noise model is: 0.9134001825335245\n",
      "\n",
      "Total fidelity between Ankaa-3 and noise-free is: 0.8668010125433862\n"
     ]
    }
   ],
   "source": [
    "f_simple = fidelity(df[\"simple_noisy_sim\"], df[\"Ankaa-3\"])\n",
    "\n",
    "print(f\"\\nTotal fidelity between Ankaa-3 and full noise model is: {f_noisy_Ankaa}\")\n",
    "print(f\"\\nTotal fidelity between Ankaa-3 and simple noise model is: {f_simple}\")\n",
    "print(f\"\\nTotal fidelity between Ankaa-3 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-3\", 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-3 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": "code",
   "execution_count": 26,
   "id": "c6412d7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum Task Summary\n",
      "{<_Rigetti.Ankaa3: 'arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3'>: {'shots': 10000, 'tasks': {'COMPLETED': 1}}}\n",
      "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n",
      "Estimated cost to run this example: 9.300 USD\n"
     ]
    }
   ],
   "source": [
    "print(\"Quantum Task Summary\")\n",
    "print(t.quantum_tasks_statistics())\n",
    "print(\n",
    "    \"Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\"\n",
    ")\n",
    "print(\n",
    "    f\"Estimated cost to run this example: {t.qpu_tasks_cost() + t.simulator_tasks_cost():.3f} USD\"\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "3.10.10",
   "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
}