10-manage_real_Cdr.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9e50dda4-3aab-4724-a42b-8e8fe68a67db",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Making CDR Ready To Work With A Real Quantum Computer\n",
    "\n",
    "\n",
    "This post appeared first on [Medium](https://towardsdatascience.com/making-cdr-ready-to-work-with-a-real-quantum-computer-fcdf270a6730) and my weekly [email-course](https://pyqml.substack.com/p/making-cdr-ready-to-work-with-a-real?s=w).\n",
    "\n",
    "\n",
    "Clifford Data Regression (CDR) is a promising quantum error mitigation method. In the previous post, we effectively adapted the code from the open-source library Mitiq. As a result, we only had to apply minor adjustments to connect to the IBM Quantum cloud and to reduce the noise of a real quantum computer.\n",
    "\n",
    "However, it takes a whole day to complete the method. It doesn't take so long because it takes so much computing time. But it takes so long because the quantum circuits we submitted to the IBM cloud have been waiting a very long time to be executed.\n",
    "\n",
    "IBM offers free access to (some of) their quantum devices. But, of course, these are shared devices. When you send a quantum circuit to a quantum system on the IBM cloud, it enters a queue with jobs from other users before eventual execution. Depending on the number of enqueued jobs, it may take hours until a job runs.\n",
    "\n",
    "During our execution of the CDR, we submitted eleven circuits to the IBM cloud. The problem is that we didn't send them all immediately. But we always waited until one job was done before we sent the next. As a result, our waiting time added up significantly.\n",
    "\n",
    "Fortunately, IBM allows us to send multiple circuits concurrently. This should reduce our overall waiting time significantly.\n",
    "\n",
    "In the last post's code, we use the `execute_with_cdr` method we import from mitiq. We call it with a custom executor as a parameter--the `real_jakarta` executor. This executor is a function that takes the quantum circuit, runs it, and returns the expectation value of the observable of interest.\n",
    "\n",
    "Let's have a brief look at the code of the `execute_with_cdr` function that you find [here](https://github.com/unitaryfund/mitiq/blob/master/mitiq/cdr/cdr.py). At line 155, we call the executor's `evaluate` function and pass as the parameters a list of circuits and the observable.\n",
    "\n",
    "The list of circuits is the training circuits plus the original circuit whose expectation value we want to calculate. The CDR method builds on learning from data how to mitigate the noise. We see that we can specify the number of training circuits we want to use on closer inspection. The default value is `10`. So, we call the evaluate function with a list of eleven circuits.\n",
    "\n",
    "The executor (see its code [here](https://github.com/unitaryfund/mitiq/blob/master/mitiq/executor/executor.py)) loops through the list and \"executes\" each circuit by calling the function we provided on it.\n",
    "\n",
    "Let's briefly revisit that provided function to see how we execute a circuit.\n",
    "\n",
    "```python\n",
    "# ...\n",
    "\n",
    "mapped_circuit = transpile(circ, backend=jakarta)\n",
    "qobj = assemble(mapped_circuit, backend=jakarta, shots=shots)\n",
    "\n",
    "# execute the circuit\n",
    "job = jakarta.run(qobj)\n",
    "\n",
    "counts = job.result().get_counts()\n",
    "\n",
    "# ...\n",
    "```\n",
    "\n",
    "First, we transpile, assemble, and run the circuit on the real quantum device (Jakarta). Then, we directly obtain the's result inside the executor and, thus, inside the loop. That's the problem because `result()` is a blocking method. It does not return anything, but it waits until the job has finished. So, it waits as long as our circuit waits in the queue. Consequently, the whole loop doesn't proceed. But it waits for the result before submitting the next circuit for execution.\n",
    "\n",
    "To prevent our code from waiting, we must submit all circuits to the IBM cloud before using their results. Therefore, we need to take apart the `execute_with_cdr` function.\n",
    "\n",
    "In the first step, we prepare the training circuits. We separate this from the rest of the code because we need these circuits before and after execution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a650d5e0-7dfb-4e9f-843d-23f076a2f37f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.9/site-packages/pandas/compat/__init__.py:124: UserWarning: Could not import the lzma module. Your installed Python is incomplete. Attempting to use lzma compression will result in a RuntimeError.\n",
      "  warnings.warn(msg)\n"
     ]
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "from mitiq.interface.mitiq_qiskit import qiskit_utils\n",
    "from mitiq import Observable, PauliString\n",
    "from typing import Any, Callable, Optional, Sequence, Union\n",
    "import numpy as np\n",
    "from scipy.optimize import curve_fit\n",
    "\n",
    "from mitiq import Executor, Observable, QPROGRAM, QuantumResult\n",
    "from mitiq.cdr import (\n",
    "    generate_training_circuits,\n",
    "    linear_fit_function,\n",
    "    linear_fit_function_no_intercept,\n",
    "    is_clifford,\n",
    ")\n",
    "from mitiq.zne.scaling import fold_gates_at_random\n",
    "\n",
    "\n",
    "def prepare_training_circuits(\n",
    "    circuit: QPROGRAM,\n",
    "    observable: Optional[Observable] = None,\n",
    "    *,\n",
    "    simulator: Union[Executor, Callable[[QPROGRAM], QuantumResult]],\n",
    "    num_training_circuits: int = 10,\n",
    "    fraction_non_clifford: float = 0.1,\n",
    "    fit_function: Callable[..., float] = linear_fit_function,\n",
    "    num_fit_parameters: Optional[int] = None,\n",
    "    scale_factors: Sequence[float] = (1,),\n",
    "    **kwargs: Any,\n",
    "):\n",
    "    \"\"\"\n",
    "    Returns a list of the training circuits\n",
    "    \"\"\"\n",
    "    \n",
    "    method_select = kwargs.get(\"method_select\", \"uniform\")\n",
    "    method_replace = kwargs.get(\"method_replace\", \"closest\")\n",
    "    random_state = kwargs.get(\"random_state\", None)\n",
    "    kwargs_for_training_set_generation = {\n",
    "        \"sigma_select\": kwargs.get(\"sigma_select\"),\n",
    "        \"sigma_replace\": kwargs.get(\"sigma_replace\"),\n",
    "    }\n",
    "\n",
    "    if num_fit_parameters is None:\n",
    "        if fit_function is linear_fit_function:\n",
    "            num_fit_parameters = 1 + len(scale_factors)\n",
    "        elif fit_function is linear_fit_function_no_intercept:\n",
    "            num_fit_parameters = len(scale_factors)\n",
    "        else:\n",
    "            raise ValueError(\n",
    "                \"Must provide `num_fit_parameters` for custom fit function.\"\n",
    "            )\n",
    "\n",
    "\n",
    "    if not isinstance(simulator, Executor):\n",
    "        simulator = Executor(simulator)\n",
    "\n",
    "    # Check if circuit is already Clifford\n",
    "    if is_clifford(circuit):\n",
    "        return simulator.evaluate(circuit, observable)[0].real\n",
    "\n",
    "    # Generate training circuits.\n",
    "    training_circuits = generate_training_circuits(\n",
    "        circuit,\n",
    "        num_training_circuits,\n",
    "        fraction_non_clifford,\n",
    "        method_select,\n",
    "        method_replace,\n",
    "        random_state,\n",
    "        kwargs=kwargs_for_training_set_generation,\n",
    "    )\n",
    "\n",
    "    return training_circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f03f4ca0-fa7c-497d-8f79-e729dc639627",
   "metadata": {},
   "source": [
    "We stripped this function to contain only the parts required for generating the training circuits. But those parts we took over remain unmodified (see the [original function](https://github.com/unitaryfund/mitiq/blob/master/mitiq/cdr/cdr.py)).\n",
    "\n",
    "So, let's now use this function to create the list of circuits. For that purpose, we first reuse a few things from the previous posts, such as the `get_circuit()` function that creates the quantum circuit whose observable expectation value we aim to calculate. Further, we define this observable (`obs`), and the noiseless simulator (`sim`).\n",
    "\n",
    "Once we prepared the circuits, we reorganized them similar to the original Mitiq code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a39ae0ff-e13d-4a8f-bdbd-5db314512157",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_circuit():\n",
    "    qc = QuantumCircuit(2)\n",
    "\n",
    "    # CDR works better if the circuit is not too short. So we increase its depth.\n",
    "    for i in range(5): \n",
    "        qc.h(0) # Clifford\n",
    "        qc.h(1) # Clifford\n",
    "        qc.rz(1.75, 0)\n",
    "        qc.rz(2.31, 1)\n",
    "        qc.cx(0,1) # Clifford\n",
    "        qc.rz(-1.17, 1)\n",
    "        qc.rz(3.23, 0)\n",
    "        qc.rx(pi/2, 0) # Clifford\n",
    "        qc.rx(pi/2, 1) # Clifford\n",
    "        \n",
    "    return qc\n",
    "\n",
    "\n",
    "def sim(qc):\n",
    "    return qiskit_utils.execute_with_shots(qc, obs.matrix(), 4096)\n",
    "\n",
    "obs = Observable(PauliString(\"ZZ\"), PauliString(\"X\", coeff=-1.75))\n",
    "\n",
    "scale_factors: Sequence[float] = (1,)\n",
    "scale_noise: Callable[[QPROGRAM, float], QPROGRAM] = fold_gates_at_random\n",
    "\n",
    "training_circuits = prepare_training_circuits(\n",
    "    get_circuit(),\n",
    "    observable=obs.matrix(),\n",
    "    simulator=sim,\n",
    "    scale_factors=scale_factors,\n",
    ")\n",
    "\n",
    "\n",
    "# [Optionally] Scale noise in circuits.\n",
    "all_circuits = [\n",
    "    [scale_noise(c, s) for s in scale_factors]\n",
    "    for c in [get_circuit()] + training_circuits  # type: ignore\n",
    "]\n",
    "\n",
    "\n",
    "to_run = [circuit for circuits in all_circuits for circuit in circuits]\n",
    "all_circuits_shape = (len(all_circuits), len(all_circuits[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c82befa-d063-4cc7-b5fd-fb061935e85c",
   "metadata": {},
   "source": [
    "We store the circuits we want to run in the `to_run` variable. So, let's now create a function that submits these circuits to the IBM cloud all at once (without waiting for a result). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0e4e8941-3fd0-49dd-9b97-cc4fb14c91c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, transpile, assemble\n",
    "\n",
    "def submit_to_jakarta(\n",
    "    to_run,\n",
    "    obs: np.ndarray,\n",
    "    shots: int,\n",
    "    backend\n",
    "):\n",
    "    \n",
    "    def submit_executor(circuit):\n",
    "\n",
    "        # Avoid mutating circuit\n",
    "        circ = circuit.copy()\n",
    "        # we need to modify the circuit to measure obs in its eigenbasis\n",
    "        # we do this by appending a unitary operation\n",
    "        # obtains a U s.t. obs = U diag(eigvals) U^dag\n",
    "        eigvals, U = np.linalg.eigh(obs)\n",
    "        circ.unitary(np.linalg.inv(U), qubits=range(circ.num_qubits))\n",
    "\n",
    "        circ.measure_all()\n",
    "\n",
    "        mapped_circuit = transpile(circ, backend=backend)\n",
    "        qobj = assemble(mapped_circuit, backend=backend, shots=shots)\n",
    "\n",
    "        # execute the circuit\n",
    "        job = jakarta.run(qobj)\n",
    "        return job\n",
    "\n",
    "    \n",
    "    # cast executor and simulator inputs to Executor type\n",
    "    executor = Executor(submit_executor)\n",
    "    jobs = executor.evaluate(to_run, obs)\n",
    "    return jobs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0eb8e557-1068-4ad5-8700-bde3976cf4e3",
   "metadata": {},
   "source": [
    "The `submit_to_jakarta` function takes the `to_run` list, the observable, the number of runs per circuit (`shots`), and the `backend` we want to run the circuits. Inside this function, we declare another function `submit_executor`. This is the callback function we use as the executor. In the implementation of this function, we only prepare the circuit (transpile and assemble) and send it to the `backend` backend. The executor does not return the result but a `job`. This is a local reference to a quantum circuit submitted to a given backend. The `submit_to_jakarta` function collects all the `jobs` and returns them.\n",
    "\n",
    "Before we can use this function, we need to connect to our account and get a provider (you need to use different parameter values to connect to `ibmq_quito`) that allows us to get access to a backend, here `jakarta`. [This post](https://towardsdatascience.com/how-to-run-code-on-a-real-quantum-computer-c1fc61ff5b4) explains how to do this in more detail.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "116a99ef-cf47-40b1-a3b9-4c9c4dcec21b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# load IBMQ Account data\n",
    "from qiskit import IBMQ\n",
    "\n",
    "# replace TOKEN with your API token string (https://quantum-computing.ibm.com/lab/docs/iql/manage/account/ibmq)\n",
    "IBMQ.save_account(\"TOKEN\", overwrite=True) \n",
    "provider = IBMQ.load_account()\n",
    "\n",
    "provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')\n",
    "jakarta = provider.get_backend('ibmq_jakarta')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d86d6869-3ebe-4bb1-a836-f5eb2d0f2b0b",
   "metadata": {},
   "source": [
    "Let's see what happens when we call this function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e913462a-9680-4715-9399-e1a1dea27826",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_86/179072001.py:26: DeprecationWarning: Passing a Qobj to Backend.run is deprecated and will be removed in a future release. Please pass in circuits or pulse schedules instead.\n",
      "  job = jakarta.run(qobj)\n"
     ]
    }
   ],
   "source": [
    "jobs = submit_to_jakarta(\n",
    "    to_run,\n",
    "    obs.matrix(),\n",
    "    4096,\n",
    "    jakarta\n",
    ")\n",
    "jobs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bb45523-1c19-4bde-9766-40d114f662dd",
   "metadata": {},
   "source": [
    "The output is a list of job objects. Head over to your [IBM Quantum console](https://quantum-computing.ibm.com/). When you click \"view all\" in \"recent jobs,\" you'll see that these jobs have arrived at IBM and they are pending. You also see the approximated time of execution. In my case, they're not going to run today at all because there are more than 140 other circuits in the queue waiting.\n",
    "\n",
    "![IBMQ](./assets/ibmq2.png)\n",
    "\n",
    "If I needed any more motivation for what we do today, this would be it. \n",
    "\n",
    "At least, waiting for these jobs to run gives me  enough time to complete this post.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c02cea30-cf3c-4a10-b2ee-89011b83067f",
   "metadata": {},
   "source": [
    "\n",
    "Of course, you don't want to keep your computer up and running while we wait for the results. So, we need to persist these jobs. Fortunately, each job has an id we can use to get it back later. If you use a Jupyter notebook, you can print the ids into the output of a cell and save them alongside your notebook.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ca3da2ff-a31f-4b98-a044-964ae3905089",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'6218d0f147f37310a6377ee0',\n",
      "'6218d0f3a2eeaa7a80ad27c8',\n",
      "'6218d0f48c4ac898e4687d1c',\n",
      "'6218d0f5a2eeaa782fad27c9',\n",
      "'6218d0f7f0b807c602db65b0',\n",
      "'6218d0f8a16487a0ade6eb39',\n",
      "'6218d0fa3895be83e73e214f',\n",
      "'6218d0fbf0b8079824db65b1',\n",
      "'6218d0fc5ac21f18a4473086',\n",
      "'6218d0fe976d9fc87220be83',\n",
      "'6218d0ff3f99d49bef399494',\n"
     ]
    }
   ],
   "source": [
    "for job in jobs:\n",
    "    print(\"'{}',\".format(job.job_id()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f084ea69-74c9-4848-b8f0-6c0338260940",
   "metadata": {},
   "source": [
    "We see a list of eleven job ids.\n",
    "\n",
    "You can use them to obtain a new job object through the `jakarta.retrieve_job(\"JOB_ID\")` function. So, let's put these into an array that we can work with. Here, I use the ids of previous runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f94e4f1e-1b9e-4265-adc7-e738ae0506ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "finished_job_ids = [\n",
    "    \"6216307c89a5f0ba67accdc8\",\n",
    "    \"621633e989a5f0085faccdca\",\n",
    "    \"62163503bc4128148fb6acca\",\n",
    "    \"6216358612d1b60020b8202c\",\n",
    "    \"6216358612d1b60020b8202c\",\n",
    "    \"6216362557bc5470c462c379\",\n",
    "    \"6216373e12d1b6d592b8202f\",\n",
    "    \"62163784538b7855738ee875\",\n",
    "    \"62163824ffea1318711becd8\",\n",
    "    \"621638d8e206decd5890bbb1\",\n",
    "    \"6216398261cbfc3bfc62f373\"\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3b39577-c32d-438a-ab94-bd5a8ea7d3e7",
   "metadata": {},
   "source": [
    "We can easily map the list of ids to a list of the actual jobs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9a9b224b-c05b-42f6-afdb-473cb1fa5a17",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<qiskit.providers.ibmq.job.ibmqjob.IBMQJob at 0x7ff9edf09220>,\n",
       " <qiskit.providers.ibmq.job.ibmqjob.IBMQJob at 0x7ff9ed8c97c0>,\n",
       " <qiskit.providers.ibmq.job.ibmqjob.IBMQJob at 0x7ff9edd3a280>,\n",
       " <qiskit.providers.ibmq.job.ibmqjob.IBMQJob at 0x7ffa1ad16610>,\n",
       " <qiskit.providers.ibmq.job.ibmqjob.IBMQJob at 0x7ff9edf09eb0>,\n",
       " <qiskit.providers.ibmq.job.ibmqjob.IBMQJob at 0x7ff9ed9cae80>,\n",
       " <qiskit.providers.ibmq.job.ibmqjob.IBMQJob at 0x7ffa1ad160d0>,\n",
       " <qiskit.providers.ibmq.job.ibmqjob.IBMQJob at 0x7ff9ed8b47c0>,\n",
       " <qiskit.providers.ibmq.job.ibmqjob.IBMQJob at 0x7ff9edf09a30>,\n",
       " <qiskit.providers.ibmq.job.ibmqjob.IBMQJob at 0x7ff9edf095e0>,\n",
       " <qiskit.providers.ibmq.job.ibmqjob.IBMQJob at 0x7ff9edf09190>]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "finished_jobs = list(map(jakarta.retrieve_job, finished_job_ids))\n",
    "finished_jobs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91c3b2f5-480a-423d-8fec-d051aac11eb3",
   "metadata": {},
   "source": [
    "Once these jobs are complete, we can obtain their results without further waiting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "27034889-44e0-45b0-9104-b4c2e174e7dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Result(backend_name='ibmq_jakarta', backend_version='1.0.28', qobj_id='471fdd0a-c273-4ea4-aded-28f0ed4b0ed7', job_id='6216307c89a5f0ba67accdc8', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(counts={'0x0': 238, '0x1': 41, '0x2': 49, '0x3': 696}), header=QobjExperimentHeader(qubit_labels=[['q', 0], ['q', 1], ['q', 2], ['q', 3], ['q', 4], ['q', 5], ['q', 6]], n_qubits=7, qreg_sizes=[['q', 7]], clbit_labels=[['meas', 0], ['meas', 1]], memory_slots=2, creg_sizes=[['meas', 2]], name='circuit-3333', global_phase=4.71238898038469, metadata={}))], date=2022-02-23 13:17:22+00:00, status=Successful completion, status=QobjHeader(backend_name='ibmq_jakarta', backend_version='1.0.28'), execution_id='ec06e180-94aa-11ec-ac54-bc97e15b08d0', time_taken=5.931757688522339, error=None, client_version={'qiskit': '0.33.0'})"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "finished_jobs[0].result()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8b50e20-479c-458f-8101-e091cc13cfb7",
   "metadata": {},
   "source": [
    "So, let's write another function that processes the job results. It takes the jobs and the observable. Again, we define an executor inside this function that does the actual work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5748b03b-96b0-454b-a544-ddae47286d34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-2.01556444 -2.01556444  2.01556444  2.01556444]\n",
      "[-2.01556444 -2.01556444  2.01556444  2.01556444]\n",
      "[-2.01556444 -2.01556444  2.01556444  2.01556444]\n",
      "[-2.01556444 -2.01556444  2.01556444  2.01556444]\n",
      "[-2.01556444 -2.01556444  2.01556444  2.01556444]\n",
      "[-2.01556444 -2.01556444  2.01556444  2.01556444]\n",
      "[-2.01556444 -2.01556444  2.01556444  2.01556444]\n",
      "[-2.01556444 -2.01556444  2.01556444  2.01556444]\n",
      "[-2.01556444 -2.01556444  2.01556444  2.01556444]\n",
      "[-2.01556444 -2.01556444  2.01556444  2.01556444]\n",
      "[-2.01556444 -2.01556444  2.01556444  2.01556444]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.9172392848406065,\n",
       " 0.5629408486360803,\n",
       " 0.4802712135216911,\n",
       " 0.8463795975997012,\n",
       " 0.8463795975997012,\n",
       " 0.7204068202825363,\n",
       " 0.6259272372946627,\n",
       " 0.7322167681560205,\n",
       " 0.7400900667383433,\n",
       " 0.7440267160295047,\n",
       " 0.1417193744818105]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def process_jobs(\n",
    "    jobs,\n",
    "    obs: np.ndarray\n",
    "):\n",
    "    \n",
    "    def process_executor(job):\n",
    "        eigvals, U = np.linalg.eigh(obs.matrix())\n",
    "        counts = job.result().get_counts()\n",
    "        expectation = 0\n",
    "\n",
    "        for bitstring, count in counts.items():\n",
    "            expectation += (\n",
    "                eigvals[int(bitstring[0 : get_circuit().num_qubits], 2)] * count / job.result().results[0].shots\n",
    "            )\n",
    "        return expectation\n",
    "\n",
    "\n",
    "    results = list(map(process_executor, jobs))\n",
    "    return results\n",
    "\n",
    "exp_values = process_jobs(finished_jobs, obs)\n",
    "exp_values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5353cc25-5f5f-45c2-91ab-3777ec433c58",
   "metadata": {},
   "source": [
    "When we process the jobs, we receive a list of expectation values. Similar to Mitiq's original function, we need to combine these with the noise-free measurements we get from the simulator. So, let's do these steps, too, to get the error-mitigated measurement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5261bc19-2e04-41b9-9f11-2212fa0c3832",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.56294085 0.48027121 0.8463796  0.8463796  0.72040682 0.62592724\n",
      "  0.73221677 0.74009007 0.74402672 0.14171937]] [0.91723928] [-0.13531499  1.12711203]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.0029958033732036"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simulator = Executor(sim)\n",
    "num_fit_parameters = 1 + len((1,),)\n",
    "results = simulator.evaluate(training_circuits, obs.matrix())\n",
    "ideal_results = np.array(results)\n",
    "\n",
    "noisy_results = np.array(exp_values).reshape(all_circuits_shape)\n",
    "\n",
    "# Do the regression.\n",
    "fitted_params, _ = curve_fit(\n",
    "    lambda x, *params: linear_fit_function(x, params),\n",
    "    noisy_results[1:, :].T,\n",
    "    ideal_results,\n",
    "    p0=np.zeros(num_fit_parameters),\n",
    ")\n",
    "print (noisy_results[1:, :].T, noisy_results[0, :], fitted_params)\n",
    "\n",
    "jakarta_mitigated_measurement = linear_fit_function(noisy_results[0, :], fitted_params)\n",
    "jakarta_mitigated_measurement"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4699bca-2238-441f-a7e3-24e4b4a17e77",
   "metadata": {},
   "source": [
    "So, let's calculate the ideal (noise-free) and the unmitigated measurement. When we created the list of circuits to run, the very first was the unmodified circuit. We can use this to calculate the unmitigated measurement, too.\n",
    "\n",
    "Finally, we can calculate and print the key performance indicators of the mitigation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d2ea0d86-9662-4a19-b341-c7d57ad37c9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error (unmitigated): 0.06987552491811488\n",
      "Error (mitigated with CDR): 0.026457842276776833\n",
      "Relative error (unmitigated): 0.07078763708873381\n",
      "Relative error (mitigated with CDR): 0.026803206694106713\n",
      "Error reduction with CDR: 62.1%.\n"
     ]
    }
   ],
   "source": [
    "ideal_measurement = obs.expectation(get_circuit(), sim).real\n",
    "jakarta_unmitigated_measurement = obs.expectation(get_circuit(), lambda x: exp_values[0]).real\n",
    "jakarta_error_unmitigated = abs(jakarta_unmitigated_measurement-ideal_measurement)\n",
    "jakarta_error_mitigated = abs(jakarta_mitigated_measurement-ideal_measurement)\n",
    "\n",
    "print(\"Error (unmitigated):\", jakarta_error_unmitigated)\n",
    "print(\"Error (mitigated with CDR):\", jakarta_error_mitigated)\n",
    "print(\"Relative error (unmitigated):\", (jakarta_error_unmitigated/ideal_measurement))\n",
    "print(\"Relative error (mitigated with CDR):\", jakarta_error_mitigated/ideal_measurement)\n",
    "print(f\"Error reduction with CDR: {(jakarta_error_unmitigated-jakarta_error_mitigated)/jakarta_error_unmitigated :.1%}.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2985e725-ace3-4d58-bd18-5861cc660b28",
   "metadata": {},
   "source": [
    "The results show an error reduction of more than 60%. Even though this is not as good as the mitigation of the simulated measurements we achieved in the previous posts, it is a decent improvement over the unmitigated result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9fdf93c-3c6c-4ed9-877c-44e235e2ac47",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}