Merge pull request #864 from qiboteam/2q_rb_interleaved

Interleaved RB

src/qibocal/protocols/__init__.py

@@ -46,6 +46,7 @@
 from .randomized_benchmarking.filtered_rb import filtered_rb
 from .randomized_benchmarking.standard_rb import standard_rb
 from .randomized_benchmarking.standard_rb_2q import standard_rb_2q
+from .randomized_benchmarking.standard_rb_2q_inter import standard_rb_2q_inter
 from .readout_characterization import readout_characterization
 from .readout_mitigation_matrix import readout_mitigation_matrix
 from .readout_optimization.resonator_amplitude import resonator_amplitude
@@ -145,5 +146,6 @@
     "rabi_length_frequency",
     "rabi_length_frequency_signal",
     "standard_rb_2q",
+    "standard_rb_2q_inter",
     "optimize_two_qubit_gate",
 ]

src/qibocal/protocols/randomized_benchmarking/filtered_rb.py

@@ -42,7 +42,7 @@ def _acquisition(
         RBData: The depths, samples and ground state probability of each experiment in the scan.
     """
 
-    return rb_acquisition(params, targets, platform, add_inverse_layer=False)
+    return rb_acquisition(params, platform, targets, add_inverse_layer=False)
 
 
 def _fit(data: RBData) -> FilteredRBResult:

src/qibocal/protocols/randomized_benchmarking/standard_rb.py

@@ -88,7 +88,7 @@ def _acquisition(
         RBData: The depths, samples and ground state probability of each experiment in the scan.
     """
 
-    return rb_acquisition(params, targets, platform)
+    return rb_acquisition(params, platform, targets)
 
 
 def _fit(data: RBData) -> StandardRBResult:
@@ -120,7 +120,6 @@ def _plot(
     """
     if isinstance(target, list):
         target = tuple(target)
-
     qubit = target
     fig = go.Figure()
     fitting_report = ""

src/qibocal/protocols/randomized_benchmarking/standard_rb_2q.py

@@ -32,7 +32,7 @@ def _acquisition(
 ) -> RB2QData:
     """Data acquisition for two qubit Standard Randomized Benchmarking."""
 
-    return twoq_rb_acquisition(params, targets, platform)
+    return twoq_rb_acquisition(params, platform, targets)
 
 
 def _fit(data: RB2QData) -> StandardRBResult:

src/qibocal/protocols/randomized_benchmarking/standard_rb_2q_inter.py

@@ -0,0 +1,96 @@
+from dataclasses import dataclass, fields
+
+import numpy as np
+from qibolab.platform import Platform
+from qibolab.qubits import QubitPairId
+
+from qibocal.auto.operation import Routine
+from qibocal.protocols.randomized_benchmarking.standard_rb import _plot
+from qibocal.protocols.randomized_benchmarking.standard_rb_2q import (
+    StandardRB2QParameters,
+)
+
+from .utils import RB2QInterData, StandardRBResult, fit, twoq_rb_acquisition
+
+
+@dataclass
+class StandardRB2QInterParameters(StandardRB2QParameters):
+    """Parameters for the standard 2q randomized benchmarking protocol."""
+
+    interleave: str = "CZ"
+    """Gate to interleave"""
+
+
+@dataclass
+class StandardRB2QInterResult(StandardRBResult):
+    """Standard RB outputs."""
+
+    fidelity_cz: dict[QubitPairId, list] = None
+    """The overall fidelity for the CZ gate and its uncertainty."""
+
+    def __contains__(self, value: QubitPairId):
+        if isinstance(value, list):
+            value = tuple(value)
+        return all(
+            value in getattr(self, field.name)
+            for field in fields(self)
+            if isinstance(getattr(self, field.name), dict)
+            and field.name != "fidelity_cz"
+        )
+
+
+def _acquisition(
+    params: StandardRB2QInterParameters,
+    platform: Platform,
+    targets: list[QubitPairId],
+) -> RB2QInterData:
+    """Data acquisition for two qubit Interleaved Randomized Benchmarking."""
+
+    data = twoq_rb_acquisition(params, platform, targets, interleave=params.interleave)
+
+    fidelity = {}
+    for target in targets:
+        fidelity[target] = platform.pairs[target].gate_fidelity
+    data.fidelity = fidelity
+
+    return data
+
+
+def _fit(data: RB2QInterData) -> StandardRB2QInterResult:
+    """Takes a data frame, extracts the depths and the signal and fits it with an
+    exponential function y = Ap^x+B.
+
+    Args:
+        data: Data from the data acquisition stage.
+
+    Returns:
+        StandardRB2QInterResult: Aggregated and processed data.
+    """
+
+    qubits = data.pairs
+    results = fit(qubits, data)
+
+    fidelity_cz = {}
+    for qubit in qubits:
+        if qubit in data.fidelity and data.fidelity[qubit] is not None:
+            fid_cz = results.fidelity[qubit] / data.fidelity[qubit][0]
+            uncertainty_cz = np.sqrt(
+                1
+                / data.fidelity[qubit][0] ** 2
+                * results.fit_uncertainties[qubit][1] ** 2
+                + (results.fidelity[qubit] / data.fidelity[qubit][0] ** 2) ** 2
+                * data.fidelity[qubit][1] ** 2
+            )
+            fidelity_cz[qubit] = [fid_cz, uncertainty_cz]
+
+    return StandardRB2QInterResult(
+        results.fidelity,
+        results.pulse_fidelity,
+        results.fit_parameters,
+        results.fit_uncertainties,
+        results.error_bars,
+        fidelity_cz,
+    )
+
+
+standard_rb_2q_inter = Routine(_acquisition, _fit, _plot)

src/qibocal/protocols/randomized_benchmarking/utils.py

@@ -122,14 +122,15 @@ def random_circuits(
     inverse_layer=True,
     single_qubit=True,
     file_inv=pathlib.Path(),
+    interleave=None,
 ) -> Iterable:
     """Returns random (self-inverting) Clifford circuits."""
 
     circuits = []
     indexes = defaultdict(list)
     for _ in range(niter):
         for target in targets:
-            circuit, random_index = layer_circuit(rb_gen, depth, target)
+            circuit, random_index = layer_circuit(rb_gen, depth, target, interleave)
             if inverse_layer:
                 add_inverse_layer(circuit, rb_gen, single_qubit, file_inv)
             add_measurement_layer(circuit)
@@ -307,6 +308,14 @@ def extract_probabilities(self, qubits):
         return probs
 
 
+@dataclass
+class RB2QInterData(RB2QData):
+    """The output of the acquisition function."""
+
+    fidelity: dict[QubitPairId, list] = field(default_factory=dict)
+    """The interleaved fidelity of this qubit."""
+
+
 @dataclass
 class StandardRBResult(Results):
     """Standard RB outputs."""
@@ -319,26 +328,32 @@ class StandardRBResult(Results):
     """Raw fitting parameters."""
     fit_uncertainties: dict[QubitId, list[float]]
     """Fitting parameters uncertainties."""
-    error_bars: dict[QubitId, Optional[Union[float, list[float]]]] = None
+    error_bars: dict[QubitId, Optional[Union[float, list[float]]]] = field(
+        default_factory=dict
+    )
     """Error bars for y."""
 
 
 def setup(
     params: Parameters,
+    platform: Platform,
     single_qubit: bool = True,
+    interleave: Optional[str] = None,
 ):
     """
     Set up the randomized benchmarking experiment backend, noise model and data class.
 
     Args:
         params (Parameters): The parameters for the experiment.
         single_qubit (bool, optional): Flag indicating whether the experiment is for a single qubit or two qubits. Defaults to True.
+        interleave: (str, optional): The type of interleaving to apply. Defaults to None.
 
     Returns:
         tuple: A tuple containing the experiment data, noise model, and backend.
     """
 
     backend = GlobalBackend()
+    backend.platform = platform
     # For simulations, a noise model can be added.
     noise_model = None
     if params.noise_model is not None:
@@ -351,7 +366,12 @@ def setup(
         noise_model = getattr(noisemodels, params.noise_model)(params.noise_params)
         params.noise_params = noise_model.params.tolist()
     # Set up the scan (here an iterator of circuits of random clifford gates with an inverse).
-    cls = RBData if single_qubit else RB2QData
+    if single_qubit:
+        cls = RBData
+    elif interleave is not None:
+        cls = RB2QInterData
+    else:
+        cls = RB2QData
     data = cls(
         depths=params.depths,
         uncertainties=params.uncertainties,
@@ -405,6 +425,7 @@ def get_circuits(
             add_inverse_layer,
             single_qubit,
             inv_file,
+            interleave,
         )
 
         circuits.extend(circuits_depth)
@@ -464,8 +485,8 @@ def execute_circuits(circuits, targets, params, backend, single_qubit=True):
 
 def rb_acquisition(
     params: Parameters,
-    targets: list[QubitId],
     platform: Platform,
+    targets: list[QubitId],
     add_inverse_layer: bool = True,
     interleave: str = None,
 ) -> RBData:
@@ -482,8 +503,7 @@ def rb_acquisition(
     Returns:
         RBData: The depths, samples, and ground state probability of each experiment in the scan.
     """
-    data, noise_model, backend = setup(params, single_qubit=True)
-    backend.platform = platform
+    data, noise_model, backend = setup(params, platform, single_qubit=True)
     circuits, indexes, npulses_per_clifford = get_circuits(
         params, targets, add_inverse_layer, interleave, noise_model, single_qubit=True
     )
@@ -512,11 +532,11 @@ def rb_acquisition(
 
 def twoq_rb_acquisition(
     params: Parameters,
-    targets: list[QubitPairId],
     platform: Platform,
+    targets: list[QubitPairId],
     add_inverse_layer: bool = True,
     interleave: str = None,
-) -> RB2QData:
+) -> Union[RB2QData, RB2QInterData]:
     """
     The data acquisition stage of two qubit Standard Randomized Benchmarking.
 
@@ -530,8 +550,7 @@ def twoq_rb_acquisition(
         RB2QData: The acquired data for two qubit randomized benchmarking.
     """
 
-    data, noise_model, backend = setup(params, single_qubit=False)
-    backend.platform = platform
+    data, noise_model, backend = setup(params, platform, single_qubit=False)
     circuits, indexes, npulses_per_clifford = get_circuits(
         params, targets, add_inverse_layer, interleave, noise_model, single_qubit=False
     )
@@ -564,13 +583,16 @@ def twoq_rb_acquisition(
     return data
 
 
-def layer_circuit(rb_gen: Callable, depth: int, target) -> tuple[Circuit, dict]:
+def layer_circuit(
+    rb_gen: Callable, depth: int, target, interleave: str = None
+) -> tuple[Circuit, dict]:
     """Creates a circuit of `depth` layers from a generator `layer_gen` yielding `Circuit` or `Gate`
     and a dictionary with random indexes used to select the clifford gates.
 
     Args:
         layer_gen (Callable): Should return gates or a full circuit specifying a layer.
         depth (int): Number of layers.
+        interleave (str, optional): Interleaving pattern for the circuits. Defaults to None.
 
     Returns:
         Circuit: with `depth` many layers.
@@ -587,14 +609,19 @@ def layer_circuit(rb_gen: Callable, depth: int, target) -> tuple[Circuit, dict]:
     for _ in range(depth):
         # Generate a layer.
         new_layer, random_index = rb_gen_layer
+        random_indexes.append(random_index)
         new_circuit = Circuit(nqubits)
         if nqubits == 1:
             new_circuit.add(new_layer)
         elif nqubits == 2:
             for gate in new_layer:
                 new_circuit.add(gate)
-
-        random_indexes.append(random_index)
+            # FIXME: General interleave
+            if interleave == "CZ":
+                interleaved_clifford = rb_gen.two_qubit_cliffords["13"]
+                interleaved_clifford_gate = clifford2gates(interleaved_clifford)
+                new_circuit.add(interleaved_clifford_gate)
+                random_indexes.append("13")
 
         if full_circuit is None:  # instantiate in first loop
             full_circuit = Circuit(new_circuit.nqubits)

tests/runcards/protocols.yml

@@ -701,6 +701,14 @@ actions:
       niter: 5
       nshots: 50
 
+  - id: standard rb 2q interleaved
+    operation: standard_rb_2q_inter
+    targets: [[0,2]]
+    parameters:
+      depths: [1, 2, 3, 5]
+      niter: 5
+      nshots: 50
+
   - id: chevron cz
     operation: chevron
     targets: [[0, 2],[1,2]]