finished notebook, added properties and fixed some bugs

Author: AndersHR

3qubit Swap-test.ipynb

@@ -146,7 +146,11 @@
   {
    "cell_type": "markdown",
    "metadata": {},
-   "source": []
+   "source": [
+    "We specify the expectation value function that computes the estimated expectation value from a set of quantum circuit experiment results.\n",
+    "\n",
+    "The repeating CNOTs implementation requires the expectation value function to return both the expectation value and the variances. The random Pauli-sampling implementation requires only the expectation value. To reuse code, we specify a filter to be passed to the function that specifies the method used."
+   ]
   },
   {
    "cell_type": "code",
@@ -378,7 +382,7 @@
    ],
    "source": [
     "x = qem.noise_amplification_factors\n",
-    "y = qem.get_noise_amplified_exp_vals()\n",
+    "y = qem.noise_amplified_exp_vals\n",
     "\n",
     "plt.xlabel(r\"$r$, noise amplification factor\")\n",
     "plt.ylabel(r\"$E_r$, expectation value\")\n",
@@ -396,7 +400,11 @@
   {
    "cell_type": "markdown",
    "metadata": {},
-   "source": []
+   "source": [
+    "We plot the mitigated expectation value, as a function of the number of noise amplification factors used, and we can see a noticable improvement.\n",
+    "\n",
+    "From the plot above we observe that the noise amplified expectation values are being slightly over-estimated for the last amplification factors for the repeating CNOTs-method. Correspondingly, we observe that the mitigated expectation value flattens off and fails to improve when including these amplification factors."
+   ]
   },
   {
    "cell_type": "code",
@@ -418,7 +426,7 @@
    ],
    "source": [
     "n_amp_factors = qem.n_amp_factors\n",
-    "noise_amplified_exp_vals = qem.get_noise_amplified_exp_vals()\n",
+    "noise_amplified_exp_vals = qem.noise_amplified_exp_vals\n",
     "noise_amplification_factors = qem.noise_amplification_factors\n",
     "\n",
     "mitigated_exp_vals = np.zeros(n_amp_factors)\n",
@@ -436,16 +444,11 @@
     "plt.show()"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Zero noise extrapolation, mitigating noise on CNOT-gates, on the SWAP-test circuit. Now on the mock backend FakeVigo, which emulates IBMQ's Vigo quantum device.\n",
+    "Zero noise extrapolation, mitigating noise on CNOT-gates, on the SWAP-test circuit. Now on the mock backend FakeAthens that emulates the IBMQ Athens quantum device. This mock backend has the same configurations as the real device, and an noise model that aims to approximate the physical device as closely as possible.\n",
     "\n",
     "Noise amplification factors = [1,3,5,7,9]"
    ]
@@ -544,7 +547,11 @@
   {
    "cell_type": "markdown",
    "metadata": {},
-   "source": []
+   "source": [
+    "For comparisons we run also the zero-noise extrapolation implementation with noise amplification by random Pauli gate-sampling.\n",
+    "\n",
+    "While the repeating CNOT-method requires odd noise amplificaiton factors (1, 3, 5, ..., 2n-1), the random Pauli-method seems to work best with powers of two (1, 2, 4, ..., 2^(n-1))."
+   ]
   },
   {
    "cell_type": "code",
@@ -596,6 +603,15 @@
     "print(R[-1])"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We plot the mitigated expectation values as a function of the number of amplification factors used for both methods. We observe from the below plot that the repeating CNOTs-method converges a lot closer to the ideal expectation value than the random Pauli-method.\n",
+    "\n",
+    "The random Pauli-method relies on approximating the quantum noise as a two-qubit depolarizing noise model. Optionally, doing a pauli-twirling before applying this assumption. The repeating CNOTs-method have no such assumptions about the character of the quantum noise. Thus, we might expected the latter to work better for general noise models, and exp"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 13,
@@ -605,7 +621,6 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "(2048, 1) (2048,) (2048,)\n",
       "CNOT repetition, mitigated exp vals: [0.29174495 0.38494003 0.43351895 0.46148582 0.4778664  0.48694545\n",
       " 0.49105048]\n",
       "Random pauli gates, mitigated exp vals: [0.29193199 0.40144479 0.44075068 0.45646464 0.4634236  0.46669605\n",
@@ -628,7 +643,7 @@
    "source": [
     "# Process results from ZNE with noise amplification by CNOT repetition:\n",
     "n_amp_factors = qem.n_amp_factors\n",
-    "noise_amplified_exp_vals = qem.get_noise_amplified_exp_vals()\n",
+    "noise_amplified_exp_vals = qem.noise_amplified_exp_vals\n",
     "noise_amplification_factors = qem.noise_amplification_factors\n",
     "\n",
     "mitigated_exp_vals = np.zeros(n_amp_factors)\n",
@@ -672,14 +687,9 @@
   {
    "cell_type": "markdown",
    "metadata": {},
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
+   "source": [
+    "Qiskit version:"
+   ]
   },
   {
    "cell_type": "code",
@@ -705,13 +715,6 @@
    "source": [
     "qiskit.__qiskit_version__"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

zero_noise_extrapolation_cnot.py

@@ -17,8 +17,6 @@
 sys.path.append(abs_path)
 sys.path.append(os.path.dirname(abs_path))
 
-from zero_noise_extrapolation import Richardson_extrapolate
-
 from typing import Callable, Union
 
 """
@@ -63,21 +61,26 @@ class ZeroNoiseExtrapolationResult:
     gamma_coefficients: ndarray
     exp_val: float
 
-    def get_bare_exp_val(self) -> float:
+    @property
+    def bare_exp_val(self) -> float:
         return self.noise_amplified_results[0].exp_val
 
-    def get_noise_amplified_exp_vals(self) -> ndarray:
+    @property
+    def noise_amplified_exp_vals(self) -> ndarray:
         return asarray([result.exp_val for result in self.noise_amplified_results])
 
-    def get_noise_amplified_variances(self) -> ndarray:
+    @property
+    def noise_amplified_variances(self) -> ndarray:
         return asarray([result.variance for result in self.noise_amplified_results])
 
-    def get_noise_amplified_circuit_depths(self) -> ndarray:
-        return asarray([result.qc.depth() for result in self.noise_amplified_results])
-
-    def get_noise_amplified_circuit_shots(self) -> ndarray:
+    @property
+    def shots(self) -> ndarray:
         return asarray([result.shots for result in self.noise_amplified_results])
 
+    @property
+    def depths(self) -> ndarray:
+        return asarray([result.qc.depth() for result in self.noise_amplified_results])
+
 
 # Zero-noise extrapolation class:
 class ZeroNoiseExtrapolation:
@@ -206,8 +209,6 @@ def __init__(self, qc: QuantumCircuit, exp_val_func: Callable, backend=None, exp
 
         self.result = None
 
-        self.mitigated_exp_val = None
-
     @staticmethod
     def partition_shots(tot_shots: int) -> (int, int):
         """
@@ -234,14 +235,79 @@ def partition_shots(tot_shots: int) -> (int, int):
                 repeats = (tot_shots // 8192) + 1
             return int(tot_shots / repeats), repeats
 
-    # Useful set and get functions:
+    # We use the @property decorator for certain useful data that we might want to retrieve that are stored within the
+    # noise amplified results
+
+    @property
+    def bare_exp_val(self) -> float:
+        return self.noise_amplified_results[0].exp_val
 
-    def get_noise_amplified_exp_vals(self) -> ndarray:
+    @property
+    def noise_amplified_exp_vals(self) -> ndarray:
         return asarray([result.exp_val for result in self.noise_amplified_results])
 
-    # Error mitigation help functions:
+    @property
+    def noise_amplified_variances(self) -> ndarray:
+        return asarray([result.variance for result in self.noise_amplified_results])
+
+    @property
+    def depths(self) -> ndarray:
+        return asarray([result.qc.depth() for result in self.noise_amplified_results])
+
+    @property
+    def mitigated_exp_val(self) -> float:
+        if self.result is None:
+            return None
+        return self.result.exp_val
+
+    # Functions for computing the Richardson extrapolation
+
+    def extrapolate(self, noise_amplified_exp_vals: ndarray):
+        """
+        The Richardson extrapolation reads
+
+        E^* = \sum_i gamma_i * E(\lambda_i),
+
+        where the gamma_i-coefficients are computed as a function of the amplification factors by solving a system
+        of linear equations, this is done in self.compute_extrapolation_coefficients(), and E(\lambda_i) is the
+        i-th noise amplified expectation value, corresponding to the amplification factor \lambda_i.
+
+        Ref: https://doi.org/10.1098/rsta.1911.0009
+
+        Parameters
+        ----------
+        noise_amplified_exp_vals: numpy.ndarray
+            The noise amplified expectation value, in order corresponding to amplification factors 1, 3, 5, ... , 2n-1.
+
+        Returns
+        -------
+        mitigated_exp_val: float
+            The mitigated expectation value, which is the exp val extrapolated to the zero-noise case.
+        """
+        if self.n_amp_factors == 1:
+            return noise_amplified_exp_vals[0]
+        if not shape(noise_amplified_exp_vals)[0] == shape(self.gamma_coefficients)[0]:
+            raise Exception("Shape mismatch between noise_amplified_exp_vals and gamma_coefficients." +
+                            " length={:}".format(shape(noise_amplified_exp_vals)[0]) +
+                            " does not match length={:}".format(shape(self.gamma_coefficients)[0]))
+        return dot(transpose(noise_amplified_exp_vals), self.gamma_coefficients)[0]
 
     def compute_extrapolation_coefficients(self, n_amp_factors: int = None) -> ndarray:
+        """
+        Compute the gamma_i-coefficients used in the Richardson extrapolation. We assume the specific noise
+        amplification factors to be 1, 3, 5, ..., 2n-1, where n=n_amp_factors is the number of noise amplification
+        factors.
+
+        Parameters
+        ----------
+        n_amp_factors: int
+            Number of amplification factors.
+
+        Returns
+        ----------
+        gamma_coefficients: numpy.ndarray
+            The set of coefficients to be used in the Richardson extrapolation.
+        """
         if n_amp_factors is None:
             n_amp_factors = self.n_amp_factors
         if n_amp_factors == 1:
@@ -251,7 +317,7 @@ def compute_extrapolation_coefficients(self, n_amp_factors: int = None) -> ndarr
 
         A, b = zeros((n_amp_factors, n_amp_factors)), zeros((n_amp_factors, 1))
 
-        A[0,:], b[0] = 1, 1
+        A[0, :], b[0] = 1, 1
 
         for k in range(1, n_amp_factors):
             A[k, :] = amplification_factors**k
@@ -260,14 +326,7 @@ def compute_extrapolation_coefficients(self, n_amp_factors: int = None) -> ndarr
 
         return gamma_coefficients
 
-    def extrapolate(self, noise_amplified_exp_vals: ndarray):
-        if self.n_amp_factors == 1:
-            return noise_amplified_exp_vals[0]
-        if not shape(noise_amplified_exp_vals)[0] == shape(self.gamma_coefficients)[0]:
-            raise Exception("Shape mismatch between noise_amplified_exp_vals and gamma_coefficients." +
-                            " length={:}".format(shape(noise_amplified_exp_vals)[0]) +
-                            " does not match length={:}".format(shape(self.gamma_coefficients)[0]))
-        return dot(transpose(noise_amplified_exp_vals), self.gamma_coefficients)[0]
+    # Functions involved in saving and loading results from disk
 
     def set_experiment_name(self, experiment_name):
         """
@@ -352,6 +411,8 @@ def write_to_file(self, filename: str, data):
         pickle.dump(data, file)
         file.close()
 
+    # Functions for processing and executing the quantum circuits
+
     def noise_amplify_and_pauli_twirl_cnots(self, qc: QuantumCircuit, amp_factor: int,
                                             pauli_twirl: bool) -> QuantumCircuit:
         """
@@ -505,6 +566,8 @@ def execute_circuit(self, qc: QuantumCircuit, shots=None) -> Result:
 
         return circuit_measurement_results
 
+    # Functions involved in computing the noise amplified and mitigated expectation values and related measures.
+
     def compute_exp_val(self, result: Result) -> (float, float, ndarray):
         """
         Compute the expectation value and variance for a set of circuit executions. We assume that all separate circuit
@@ -695,9 +758,7 @@ def mitigate(self, verbose: bool = False) -> float:
                       "variance = {:.8f}, ".format(noise_amplified_result.variance) +
                       "total shots executed = {:}.".format(noise_amplified_result.shots))
 
-        mitigated_exp_val = self.extrapolate(self.get_noise_amplified_exp_vals())
-
-        self.mitigated_exp_val = mitigated_exp_val
+        mitigated_exp_val = self.extrapolate(self.noise_amplified_exp_vals)
 
         self.result = ZeroNoiseExtrapolationResult(qc=self.qc,
                                                    noise_amplified_results=self.noise_amplified_results,
@@ -708,9 +769,9 @@ def mitigate(self, verbose: bool = False) -> float:
 
         if verbose:
             print("-----\nERROR MITIGATION DONE\n" +
-                  "Bare circuit expectation value: {:.8f}\n".format(self.result.get_bare_exp_val()) +
-                  "Noise amplified expectation values: {:}\n".format(self.result.get_noise_amplified_exp_vals()) +
-                  "Circuit depths: {:}\n".format(self.result.get_noise_amplified_circuit_depths()) +
+                  "Bare circuit expectation value: {:.8f}\n".format(self.result.bare_exp_val) +
+                  "Noise amplified expectation values: {:}\n".format(self.result.noise_amplified_exp_vals) +
+                  "Circuit depths: {:}\n".format(self.result.depths) +
                   "-----\n" +
                   "Mitigated expectation value: {:.8f}\n".format(self.result.exp_val))