Error_mitigation_code_Bootcamp3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Error_mitigation_code_Bootcamp3.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Error Mitigation Algorithm: For a GHZ State. \n",
        "\n",
        "- María Agudo\n",
        "- Giuseppe Scolamiero\n",
        "- Delimar Nanín\n",
        "- Alejandro Rea\n",
        "- Larry Rivero\n",
        "- Daniela Salas\n",
        "\n",
        "Tutors: \n",
        "- Manuel Morgado, University of Strasbourg.\n",
        "- Faisal Alam, University of Illinois Urbana-Champaign.\n"
      ],
      "metadata": {
        "id": "H98g1urZhqrc"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EuEGJtHRSvev"
      },
      "outputs": [],
      "source": [
        "pip install qiskit "
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from qiskit import * \n",
        "\n",
        "try:\n",
        "  !pip install pylatexenc\n",
        "  estilo = 'mpl'\n",
        "  QuantumCircuit(1).draw(estilo)\n",
        "except:\n",
        "  estilo = 'text'\n",
        "  \n",
        "from qiskit.visualization import plot_histogram\n",
        "from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "__mCi3VNS2vO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from qiskit.visualization import array_to_latex"
      ],
      "metadata": {
        "id": "0o8buJYUTplZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "qreg = QuantumRegister(3) #3 qubits, we can add them later to a circuit\n",
        "#complete_meas_cal(a QuantumRegister, a ClassicalRegister or a qubit_list) \n",
        "meas_calib, state_lab = complete_meas_cal(qr=qreg, circlabel='mcal')"
      ],
      "metadata": {
        "id": "_63Wl6YKTEHP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "state_lab"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M3iwnRODTMdZ",
        "outputId": "4be5f144-7fde-4b81-f68c-1a4fcd5cf668"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['000', '001', '010', '011', '100', '101', '110', '111']"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for circuit in meas_calib: #Print each circuit in meas_calibs (2^3 circuits for 3 qubits)\n",
        "    print('Circuit',circuit.name,'\\n')\n",
        "    print(circuit)\n",
        "    print()"
      ],
      "metadata": {
        "id": "ck0rLH_fTbRP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "db9daac8-9dbb-41e6-c12b-6b8386845c04"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Circuit mcalcal_000 \n",
            "\n",
            "       ░ ┌─┐      \n",
            "q0_0: ─░─┤M├──────\n",
            "       ░ └╥┘┌─┐   \n",
            "q0_1: ─░──╫─┤M├───\n",
            "       ░  ║ └╥┘┌─┐\n",
            "q0_2: ─░──╫──╫─┤M├\n",
            "       ░  ║  ║ └╥┘\n",
            "c0: 3/════╩══╩══╩═\n",
            "          0  1  2 \n",
            "\n",
            "Circuit mcalcal_001 \n",
            "\n",
            "      ┌───┐ ░ ┌─┐      \n",
            "q0_0: ┤ X ├─░─┤M├──────\n",
            "      └───┘ ░ └╥┘┌─┐   \n",
            "q0_1: ──────░──╫─┤M├───\n",
            "            ░  ║ └╥┘┌─┐\n",
            "q0_2: ──────░──╫──╫─┤M├\n",
            "            ░  ║  ║ └╥┘\n",
            "c0: 3/═════════╩══╩══╩═\n",
            "               0  1  2 \n",
            "\n",
            "Circuit mcalcal_010 \n",
            "\n",
            "            ░ ┌─┐      \n",
            "q0_0: ──────░─┤M├──────\n",
            "      ┌───┐ ░ └╥┘┌─┐   \n",
            "q0_1: ┤ X ├─░──╫─┤M├───\n",
            "      └───┘ ░  ║ └╥┘┌─┐\n",
            "q0_2: ──────░──╫──╫─┤M├\n",
            "            ░  ║  ║ └╥┘\n",
            "c0: 3/═════════╩══╩══╩═\n",
            "               0  1  2 \n",
            "\n",
            "Circuit mcalcal_011 \n",
            "\n",
            "      ┌───┐ ░ ┌─┐      \n",
            "q0_0: ┤ X ├─░─┤M├──────\n",
            "      ├───┤ ░ └╥┘┌─┐   \n",
            "q0_1: ┤ X ├─░──╫─┤M├───\n",
            "      └───┘ ░  ║ └╥┘┌─┐\n",
            "q0_2: ──────░──╫──╫─┤M├\n",
            "            ░  ║  ║ └╥┘\n",
            "c0: 3/═════════╩══╩══╩═\n",
            "               0  1  2 \n",
            "\n",
            "Circuit mcalcal_100 \n",
            "\n",
            "            ░ ┌─┐      \n",
            "q0_0: ──────░─┤M├──────\n",
            "            ░ └╥┘┌─┐   \n",
            "q0_1: ──────░──╫─┤M├───\n",
            "      ┌───┐ ░  ║ └╥┘┌─┐\n",
            "q0_2: ┤ X ├─░──╫──╫─┤M├\n",
            "      └───┘ ░  ║  ║ └╥┘\n",
            "c0: 3/═════════╩══╩══╩═\n",
            "               0  1  2 \n",
            "\n",
            "Circuit mcalcal_101 \n",
            "\n",
            "      ┌───┐ ░ ┌─┐      \n",
            "q0_0: ┤ X ├─░─┤M├──────\n",
            "      └───┘ ░ └╥┘┌─┐   \n",
            "q0_1: ──────░──╫─┤M├───\n",
            "      ┌───┐ ░  ║ └╥┘┌─┐\n",
            "q0_2: ┤ X ├─░──╫──╫─┤M├\n",
            "      └───┘ ░  ║  ║ └╥┘\n",
            "c0: 3/═════════╩══╩══╩═\n",
            "               0  1  2 \n",
            "\n",
            "Circuit mcalcal_110 \n",
            "\n",
            "            ░ ┌─┐      \n",
            "q0_0: ──────░─┤M├──────\n",
            "      ┌───┐ ░ └╥┘┌─┐   \n",
            "q0_1: ┤ X ├─░──╫─┤M├───\n",
            "      ├───┤ ░  ║ └╥┘┌─┐\n",
            "q0_2: ┤ X ├─░──╫──╫─┤M├\n",
            "      └───┘ ░  ║  ║ └╥┘\n",
            "c0: 3/═════════╩══╩══╩═\n",
            "               0  1  2 \n",
            "\n",
            "Circuit mcalcal_111 \n",
            "\n",
            "      ┌───┐ ░ ┌─┐      \n",
            "q0_0: ┤ X ├─░─┤M├──────\n",
            "      ├───┤ ░ └╥┘┌─┐   \n",
            "q0_1: ┤ X ├─░──╫─┤M├───\n",
            "      ├───┤ ░  ║ └╥┘┌─┐\n",
            "q0_2: ┤ X ├─░──╫──╫─┤M├\n",
            "      └───┘ ░  ║  ║ └╥┘\n",
            "c0: 3/═════════╩══╩══╩═\n",
            "               0  1  2 \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "aer_sim = Aer.get_backend('aer_simulator') #We choose aer_simulator as backend.\n",
        "\n",
        "#We run the circuit without noise\n",
        "t_qcirc = transpile(meas_calib, aer_sim) \n",
        "#transpile(circuits to transpile, backend) transpile: run all the circuits.\n",
        "\n",
        "qobject = assemble(t_qcirc, shots=10000) \n",
        "#assemble: Gathers a circuit list in a Qobj. \n",
        "result_calib = aer_sim.run(qobject, shots=10000).result()\n",
        "#aer_sim.run runs the simulations, .result() gives us the result for the calibration in cal_results."
      ],
      "metadata": {
        "id": "QiPH1RGHTcjC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fitter_meas = CompleteMeasFitter(result_calib, state_lab, circlabel='mcal') #Creates the calibration matrix M.\n",
        "array_to_latex(fitter_meas.cal_matrix) #In this case w/o noise we have the identity matrix."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 180
        },
        "id": "Z_dpB5GoTiD5",
        "outputId": "81b2c3a4-82ad-436a-e32c-5b1e07edab64"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<IPython.core.display.Latex object>"
            ],
            "text/latex": "$$\n\n\\begin{bmatrix}\n1 & 0 & 0 & 0 & 0 & 0 & 0 & 0  \\\\\n 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0  \\\\\n 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0  \\\\\n 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0  \\\\\n 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0  \\\\\n 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0  \\\\\n 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0  \\\\\n 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1  \\\\\n \\end{bmatrix}\n$$"
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"Here we defined the noise function \"\"\"\n",
        "\n",
        "from qiskit.providers.aer.noise import NoiseModel\n",
        "from qiskit.providers.aer.noise.errors import pauli_error, depolarizing_error\n",
        "\n",
        "def get_noise(p):\n",
        "\n",
        "    error_meas = pauli_error([('Y', p/2), ('X', p/2), ('I', 1 - p)]) \n",
        "\n",
        "    noise_model = NoiseModel() \n",
        "\n",
        "    #we add the error_meas to the noise_model.\n",
        "    noise_model.add_all_qubit_quantum_error(error_meas, \"measure\") # measurement error is applied to measurements.\n",
        "        \n",
        "    return noise_model"
      ],
      "metadata": {
        "id": "vKokRChSTi8H"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#We create a list of values to use and round them to 3 decimals.\n",
        "values_list = np.round(np.linspace(0.05, 0.50, 50), decimals=3)\n",
        "values_list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ugxRaHtVfEmv",
        "outputId": "c804aa89-deb1-4a23-e0dc-c08cf333aab5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.05 , 0.059, 0.068, 0.078, 0.087, 0.096, 0.105, 0.114, 0.123,\n",
              "       0.133, 0.142, 0.151, 0.16 , 0.169, 0.179, 0.188, 0.197, 0.206,\n",
              "       0.215, 0.224, 0.234, 0.243, 0.252, 0.261, 0.27 , 0.28 , 0.289,\n",
              "       0.298, 0.307, 0.316, 0.326, 0.335, 0.344, 0.353, 0.362, 0.371,\n",
              "       0.381, 0.39 , 0.399, 0.408, 0.417, 0.427, 0.436, 0.445, 0.454,\n",
              "       0.463, 0.472, 0.482, 0.491, 0.5  ])"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#two empty list for the loop afterwards\n",
        "noise_values = []\n",
        "fidelity_values = []"
      ],
      "metadata": {
        "id": "GJD83S5geazX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "percentage = 0.1\n",
        "noise_model = get_noise(percentage) #We add the noise, 10% probability."
      ],
      "metadata": {
        "id": "W16fxrfcTxGL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "t_qcirc = transpile(meas_calib, aer_sim)\n",
        "qobject = assemble(t_qcirc, shots=10000)\n",
        "result_calib = aer_sim.run(qobject, noise_model=noise_model, shots=10000).result()\n",
        "\n",
        "fitter_meas = CompleteMeasFitter(result_calib, state_lab, circlabel='mcal')\n",
        "array_to_latex(fitter_meas.cal_matrix) #This is the calibration matrix M "
      ],
      "metadata": {
        "id": "TJyQHqmhT2aU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 180
        },
        "outputId": "e0a0ca30-fd3a-4e36-fc18-b114e907a707"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<IPython.core.display.Latex object>"
            ],
            "text/latex": "$$\n\n\\begin{bmatrix}\n0.7246 & 0.0795 & 0.0814 & 0.0082 & 0.0745 & 0.0083 & 0.0084 & 0.0013  \\\\\n 0.0839 & 0.7237 & 0.0066 & 0.0779 & 0.0091 & 0.0843 & 0.0009 & 0.0099  \\\\\n 0.0799 & 0.01 & 0.7325 & 0.0793 & 0.0097 & 0.0008 & 0.0834 & 0.0099  \\\\\n 0.0075 & 0.086 & 0.0794 & 0.728 & 0.0011 & 0.0086 & 0.0079 & 0.0817  \\\\\n 0.0855 & 0.0088 & 0.0114 & 0.0012 & 0.733 & 0.076 & 0.078 & 0.0083  \\\\\n 0.0086 & 0.0811 & 0.0004 & 0.0097 & 0.0773 & 0.7324 & 0.0098 & 0.0829  \\\\\n 0.0093 & 0.0013 & 0.0788 & 0.0091 & 0.0849 & 0.0086 & 0.7241 & 0.0816  \\\\\n 0.0007 & 0.0096 & 0.0095 & 0.0866 & 0.0104 & 0.081 & 0.0875 & 0.7244  \\\\\n \\end{bmatrix}\n$$"
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fitter_meas.plot_calibration()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "id": "f1zINd9CT5Bi",
        "outputId": "ae2449a7-e756-44cd-b58d-ca22e14e109e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The filter works fine, we apply it to the circuit with $GHZ$ state:"
      ],
      "metadata": {
        "id": "lsQHaWfVUDDB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#GZH circuit\n",
        "qc = QuantumCircuit(3,3) \n",
        "qc.h(0) #Hadamard gate transforms |0> to |+>\n",
        "qc.cx(0,1) #CNOT gates\n",
        "qc.cx(0,2)\n",
        "qc.barrier()\n",
        "qc.measure(0,0)\n",
        "qc.measure(1,1)\n",
        "qc.measure(2,2)\n",
        "qc.draw(estilo)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 231
        },
        "id": "R-JVihg6UAN0",
        "outputId": "b99486d4-34f9-40b7-e632-d2150a0cc512"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Figure size 507.997x264.88 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "t_qc = transpile(qc, aer_sim)\n",
        "qobject = assemble(t_qc, shots=10000)\n",
        "results = aer_sim.run(qobject, noise_model=noise_model, shots=10000).result()"
      ],
      "metadata": {
        "id": "CK1iyjUjUHAA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#We get a sample of the results\n",
        "noisy_counts = results.get_counts()\n",
        "print(noisy_counts)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BB4Bo44hUpgA",
        "outputId": "5083ea20-163c-4baf-aa10-fdd9d45f3459"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'010': 461, '101': 460, '000': 3657, '111': 3617, '011': 459, '110': 476, '100': 428, '001': 442}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the filter object\n",
        "meas_filter = fitter_meas.filter\n",
        "\n",
        "# Results with mitigation\n",
        "mitigated_results = meas_filter.apply(results)\n",
        "mitigated_counts = mitigated_results.get_counts()"
      ],
      "metadata": {
        "id": "fJ0umJrVU_0q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Plot the results, mitigaded and non-mitigated (noisy)\n",
        "noisy_counts = results.get_counts()\n",
        "plot_histogram([noisy_counts, mitigated_counts], legend=['Noisy', 'Mitigated'])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 344
        },
        "id": "ZGleSR46Wk4F",
        "outputId": "1206514e-bdbb-442d-f8e0-ccda056e4a25"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<Figure size 504x360 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# What is the measurement fidelity?\n",
        "print(\"Average Measurement Fidelity: %f\" % fitter_meas.readout_fidelity())\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XtlDpnxDWsZB",
        "outputId": "598518df-4e9c-4dd9-ad27-27f9f5b9418c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Average Measurement Fidelity: 0.727838\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Loop 50 times for the noise function\n",
        "We loop the function 50 times increasing the noise probability with 50 values between 5 and 50, to calculate the fidelity and plot the data"
      ],
      "metadata": {
        "id": "bfwnyFrvSOee"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np"
      ],
      "metadata": {
        "id": "2lznjYh5MVVd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for value in values_list:\n",
        "\n",
        "#---------------\n",
        "  percentage = value #we use the list defined previously\n",
        "  noise_model = get_noise(percentage) #Add the noise.\n",
        "#---------------\n",
        "\n",
        "#---------------\n",
        "  t_qcirc = transpile(meas_calib, aer_sim)\n",
        "  qobject = assemble(t_qcirc, shots=10000)\n",
        "  result_calib = aer_sim.run(qobject, noise_model=noise_model, shots=10000).result()\n",
        "\n",
        "  fitter_meas = CompleteMeasFitter(result_calib, state_lab, circlabel='mcal')\n",
        "#--------------\n",
        "\n",
        "#--------------\n",
        "  qc = QuantumCircuit(3,3) \n",
        "  qc.h(0)\n",
        "  qc.cx(0,1) \n",
        "  qc.cx(0,2)\n",
        "  qc.barrier()\n",
        "  qc.measure(0,0)\n",
        "  qc.measure(1,1)\n",
        "  qc.measure(2,2)\n",
        "#-------------\n",
        "\n",
        "#-------------\n",
        "  t_qc = transpile(qc, aer_sim)\n",
        "  qobject = assemble(t_qc, shots=10000)\n",
        "  results = aer_sim.run(qobject, noise_model=noise_model, shots=10000).result()\n",
        "#-------------\n",
        "\n",
        "#-------------\n",
        "# Get the filter object\n",
        "  meas_filter = fitter_meas.filter\n",
        "\n",
        "# Results with mitigation\n",
        "  mitigated_results = meas_filter.apply(results)\n",
        "  mitigated_counts = mitigated_results.get_counts()\n",
        "#-------------\n",
        "\n",
        "#-------------\n",
        "  final_fidelity = fitter_meas.readout_fidelity() #average fidelity\n",
        "\n",
        "  noise_values.append(percentage)\n",
        "  fidelity_values.append(final_fidelity)\n"
      ],
      "metadata": {
        "id": "gk2xEqUgMVeo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Noise values: {noise_values}\")\n",
        "print('\\n')\n",
        "print(f\"Fidelity values: {fidelity_values}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aAFzMWZBVghr",
        "outputId": "ee0e38fa-9834-4fbd-cdfb-5424e99176f6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Noise values: [0.05, 0.059, 0.068, 0.078, 0.087, 0.096, 0.105, 0.114, 0.123, 0.133, 0.142, 0.151, 0.16, 0.169, 0.179, 0.188, 0.197, 0.206, 0.215, 0.224, 0.234, 0.243, 0.252, 0.261, 0.27, 0.28, 0.289, 0.298, 0.307, 0.316, 0.326, 0.335, 0.344, 0.353, 0.362, 0.371, 0.381, 0.39, 0.399, 0.408, 0.417, 0.427, 0.436, 0.445, 0.454, 0.463, 0.472, 0.482, 0.491, 0.5]\n",
            "\n",
            "\n",
            "Fidelity values: [0.8565750000000001, 0.8332124999999999, 0.8112625, 0.784825, 0.7615375, 0.7382875, 0.7160124999999999, 0.6939625, 0.6769125, 0.6511375, 0.6339374999999999, 0.611175, 0.59295, 0.574225, 0.557375, 0.5375749999999999, 0.5145875, 0.5023249999999999, 0.48448749999999996, 0.4664125, 0.449175, 0.4340125, 0.41605, 0.404525, 0.38708750000000003, 0.37411249999999996, 0.3617, 0.34521250000000003, 0.3349, 0.3191625, 0.3093875, 0.294625, 0.2816875, 0.2716375, 0.2613, 0.24985000000000002, 0.2382, 0.2252375, 0.21810000000000002, 0.20571250000000002, 0.1982375, 0.186525, 0.1800625, 0.17065, 0.1643125, 0.15288749999999998, 0.147675, 0.1414, 0.1345, 0.1254375]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import scipy.optimize as opt\n",
        "\n",
        "final_noise = np.array(noise_values) * 100 #to get the percentage in the correct format 0-100%\n",
        "fidelity_final = np.round(fidelity_values, decimals = 3) #rounding up the values to the format 0.000 (3 decimals)\n",
        "\n",
        "x = final_noise\n",
        "y = fidelity_final\n",
        "optimized = opt.curve_fit(lambda t,a,b: a*np.exp(b*t),  x,  y,  p0=(0.80, -0.1)) #curve fitting\n",
        "#([a, b])"
      ],
      "metadata": {
        "id": "hYh-_-svVgyB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#We have a bunch of arrays, from the first one we have [a, b]\n",
        "a = optimized[0][0]\n",
        "b = optimized[0][1]\n",
        "print(a,b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yNuSWRK7AMGd",
        "outputId": "0fc0cce5-a726-484b-f1bd-d160ff331745"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.0802313292091368 -0.03896927727165702\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Plotting the datta as a scatter plot\n",
        "plt.figure(figsize=(8,6))\n",
        "\n",
        "plt.scatter(final_noise, fidelity_values, color='m', marker='o', label='Data')\n",
        "plt.grid()\n",
        "\n",
        "plt.xlabel('Noise [%] ')\n",
        "plt.ylabel('Fidelity')\n",
        "plt.xlim(0,55)\n",
        "plt.ylim(0,1)\n",
        "\n",
        "plt.xticks(np.arange(0, len(final_noise)+1, 5))\n",
        "plt.yticks(np.arange(0, 1, 0.1))\n",
        "\n",
        "x_fitted = final_noise\n",
        "y_fitted = a*np.exp(b*x)\n",
        "plt.plot(x_fitted, y_fitted, label='Curve fitting', color='blue', lw=1.2)\n",
        "\n",
        "plt.title('Noise vs Fidelity')\n",
        "plt.legend()\n",
        "\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 404
        },
        "id": "hUATOpy-k-94",
        "outputId": "103d5800-326e-463d-f1b4-897631707bdc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 576x432 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}