notebooks/Zero_Noise_Extrapolation_(ZNE)_Task.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from scipy.optimize import curve_fit\n",
    "import matplotlib.pyplot as plt\n",
    "from qiskit import QuantumCircuit, Aer, execute\n",
    "from qiskit.providers.aer.noise import NoiseModel, depolarizing_error\n",
    "\n",
    "# Step 1: Build a simple noise model with depolarizing noise\n",
    "def create_noise_model(error_prob):\n",
    "    noise_model = NoiseModel()\n",
    "    error_gate = depolarizing_error(error_prob, 1)\n",
    "    noise_model.add_all_qubit_quantum_error(error_gate, ['u1', 'u2', 'u3'])\n",
    "    return noise_model\n",
    "\n",
    "# Step 2: Create different circuits to test noise models and choose the observable to measure\n",
    "def create_test_circuit():\n",
    "    qc = QuantumCircuit(1, 1)\n",
    "    qc.h(0)\n",
    "    qc.measure(0, 0)\n",
    "    return qc\n",
    "\n",
    "# Step 3: Apply the unitary folding method\n",
    "def apply_unitary_folding(qc, repetitions):\n",
    "    folded_qc = qc.copy()\n",
    "    for _ in range(repetitions - 1):\n",
    "        folded_qc += qc\n",
    "    return folded_qc\n",
    "\n",
    "# Step 4: Apply extrapolation method to get the zero-noise limit\n",
    "def extrapolate_zero_noise(results, extrapolation_method):\n",
    "    # Extract counts from results\n",
    "    counts = results.get_counts()\n",
    "\n",
    "    # Prepare data for extrapolation\n",
    "    x = np.array(list(counts.keys())).astype(float)\n",
    "    y = np.array(list(counts.values())).astype(float)\n",
    "\n",
    "    # Define extrapolation function based on the chosen method\n",
    "    if extrapolation_method == 'linear':\n",
    "        def extrapolation_func(x, a, b):\n",
    "            return a * x + b\n",
    "    elif extrapolation_method == 'polynomial':\n",
    "        def extrapolation_func(x, a, b, c):\n",
    "            return a * x**2 + b * x + c\n",
    "    elif extrapolation_method == 'exponential':\n",
    "        def extrapolation_func(x, a, b):\n",
    "            return a * np.exp(b * x)\n",
    "\n",
    "    # Fit the data to the extrapolation function\n",
    "    popt, _ = curve_fit(extrapolation_func, x, y)\n",
    "\n",
    "    # Extrapolate to zero noise\n",
    "    zero_noise_limit = extrapolation_func(0, *popt)\n",
    "\n",
    "    return zero_noise_limit\n",
    "\n",
    "# Step 5: Compare mitigated and unmitigated results\n",
    "def compare_results(unmitigated_counts, mitigated_counts):\n",
    "    print(\"Unmitigated Counts:\", unmitigated_counts)\n",
    "    print(\"Mitigated Counts:\", mitigated_counts)\n",
    "\n",
    "# Main function to run ZNE\n",
    "def run_zne(error_prob, extrapolation_method):\n",
    "    # Create noise model\n",
    "    noise_model = create_noise_model(error_prob)\n",
    "\n",
    "    # Create test circuit\n",
    "    test_circuit = create_test_circuit()\n",
    "\n",
    "    # Apply unitary folding\n",
    "    folded_circuit = apply_unitary_folding(test_circuit, repetitions=5)\n",
    "\n",
    "    # Simulate with noise\n",
    "    simulator = Aer.get_backend('qasm_simulator')\n",
    "    noisy_job = execute(folded_circuit, simulator, noise_model=noise_model, shots=1024)\n",
    "    noisy_results = noisy_job.result()\n",
    "\n",
    "    # Extrapolate zero noise limit\n",
    "    zero_noise_limit = extrapolate_zero_noise(noisy_results, extrapolation_method)\n",
    "\n",
    "    # Simulate without noise\n",
    "    ideal_job = execute(folded_circuit, simulator, shots=1024)\n",
    "    ideal_results = ideal_job.result()\n",
    "\n",
    "    # Compare mitigated and unmitigated results\n",
    "    unmitigated_counts = ideal_results.get_counts()\n",
    "    mitigated_counts = noisy_results.get_counts()\n",
    "    compare_results(unmitigated_counts, mitigated_counts)\n",
    "\n",
    "    return zero_noise_limit\n",
    "\n",
    "# Example usage\n",
    "error_probability = 0.1\n",
    "method = 'linear'\n",
    "zero_noise = run_zne(error_probability, method)\n",
    "print(\"Zero Noise Limit:\", zero_noise)\n",
    "\n",
    "# Plot the extrapolation curve\n",
    "x_data = np.linspace(0, 1, 100)\n",
    "plt.plot(x_data, extrapolation_func(x_data, *popt), label='Extrapolation Curve')\n",
    "plt.xlabel('Noise Level')\n",
    "plt.ylabel('Observables')\n",
    "plt.title('Extrapolation to Zero Noise Limit')\n",
    "plt.legend()\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}