Add plotting method and calculate the variance of estimated fidelity

Author: NoureldinYosri

cirq-core/cirq/experiments/xeb_fitting.py

@@ -95,6 +95,11 @@ def benchmark_2q_xeb_fidelities(
     df['e_u'] = np.sum(pure_probs**2, axis=1)
     df['u_u'] = np.sum(pure_probs, axis=1) / D
     df['m_u'] = np.sum(pure_probs * sampled_probs, axis=1)
+    # Var[m_u] = Var[sum p(x) * p_sampled(x)]
+    #           = sum p(x)^2 Var[p_sampled(x)]
+    #           = sum p(x)^2 p(x) (1 - p(x))
+    #           = sum p(x)^3 (1 - p(x))
+    df['var_m_u'] = np.sum(pure_probs**3 * (1 - pure_probs), axis=1)
     df['y'] = df['m_u'] - df['u_u']
     df['x'] = df['e_u'] - df['u_u']
     df['numerator'] = df['x'] * df['y']
@@ -103,7 +108,11 @@ def benchmark_2q_xeb_fidelities(
     def per_cycle_depth(df):
         """This function is applied per cycle_depth in the following groupby aggregation."""
         fid_lsq = df['numerator'].sum() / df['denominator'].sum()
-        ret = {'fidelity': fid_lsq}
+        # Note: both df['denominator'] an df['x'] are constants.
+        # Var[f] = Var[df['numerator']] / (sum df['denominator'])^2
+        #           = sum (df['x']^2 * df['var_m_u']) / (sum df['denominator'])^2
+        var_fid = (df['var_m_u'] * df['x'] ** 2).sum() / df['denominator'].sum() ** 2
+        ret = {'fidelity': fid_lsq, 'fidelity_variance': var_fid}
 
         def _try_keep(k):
             """If all the values for a key `k` are the same in this group, we can keep it."""
@@ -678,7 +687,7 @@ def _per_pair(f1):
             'cycle_depths': f1['cycle_depth'].values,
             'fidelities': f1['fidelity'].values,
             'a_std': a_std,
-            'layer_fid_std': layer_fid_std,
+            'layer_fid_std': np.sqrt(layer_fid_std**2 + f1['fidelity_variance'].values),
         }
         return pd.Series(record)
 

cirq-core/cirq/experiments/z_phase_calibration.py

@@ -25,6 +25,7 @@
     import cirq
     import pandas as pd
     import multiprocessing
+    import matplotlib.pyplot as plt
 
 
 def z_phase_calibration_workflow(
@@ -109,10 +110,12 @@ def z_phase_calibration_workflow(
         pool=pool,
     )
 
-    return result, xeb_fitting.before_and_after_characterization(
+    before_after = xeb_fitting.before_and_after_characterization(
         fids_df_0, characterization_result=result
     )
 
+    return result, before_after
+
 
 def calibrate_z_phases(
     sampler: 'cirq.Sampler',
@@ -191,3 +194,39 @@ def calibrate_z_phases(
         params['gamma'] = params.get('gamma', options.gamma_default or 0)
         gates[pair] = ops.PhasedFSimGate(**params)
     return gates
+
+
+def plot_z_phase_calibration_result(
+    before_after_df: 'pd.DataFrame',
+    axes: np.ndarray[Sequence[Sequence['plt.Axes']], np.dtype[np.object_]],
+    *,
+    with_error_bars: bool = False,
+) -> None:
+    """A helper method to plot the result of running z-phase calibration.
+
+    Args:
+        before_after_df: The second return object of running `z_phase_calibration_workflow`.
+        axes: And ndarray of the axes to plot on.
+            The number of axes is expected to be >= number of qubit pairs.
+        with_error_bars: Whether to add error bars or not.
+            The width of the bar is an upper bound on standard variation of the estimated fidelity.
+    """
+    for pair, ax in zip(before_after_df.index, axes.flatten()):
+        row = before_after_df.loc[[pair]].iloc[0]
+        ax.errorbar(
+            row.cycle_depths_0,
+            row.fidelities_0,
+            yerr=row.layer_fid_std_0 * with_error_bars,
+            label='original',
+        )
+        ax.errorbar(
+            row.cycle_depths_0,
+            row.fidelities_c,
+            yerr=row.layer_fid_std_c * with_error_bars,
+            label='calibrated',
+        )
+        ax.axhline(1, linestyle='--')
+        ax.set_xlabel('cycle depth')
+        ax.set_ylabel('fidelity estimate')
+        ax.set_title('-'.join(str(q) for q in pair))
+        ax.legend()