Clifford Mirror RB experiment

qiskit_experiments/library/randomized_benchmarking/mirror_rb_experiment.py

@@ -24,7 +24,8 @@
 from qiskit.providers.backend import Backend
 from qiskit.providers.options import Options
 from qiskit.exceptions import QiskitError
-from qiskit.circuit.library import CXGate, CYGate, CZGate, ECRGate, SwapGate, iSwapGate
+from qiskit.transpiler import CouplingMap
+from qiskit.circuit.library import CXGate, CYGate, CZGate, ECRGate, SwapGate
 
 from .standard_rb import StandardRB, SequenceElementType
 from .mirror_rb_analysis import MirrorRBAnalysis
@@ -43,7 +44,7 @@
 )
 
 # two qubit gates that are their own inverse
-_self_adjoint_gates = [CXGate, CYGate, CZGate, ECRGate, SwapGate, iSwapGate]
+_self_adjoint_gates = [CXGate, CYGate, CZGate, ECRGate, SwapGate]
 
 
 class MirrorRB(StandardRB):
@@ -140,9 +141,6 @@ def __init__(
         if not all(length % 2 == 0 for length in lengths):
             raise QiskitError("All lengths must be even")
 
-        if two_qubit_gate_density < 0 or two_qubit_gate_density > 1:
-            raise QiskitError("Two-qubit gate density must be between 0 and 1.")
-
         super().__init__(
             physical_qubits,
             lengths,
@@ -197,6 +195,7 @@ def _default_experiment_options(cls) -> Options:
             sampler_opts={},
             inverting_pauli_layer=False,
         )
+        options.set_validator(field="two_qubit_gate_density", validator_value=(0, 1))
 
         return options
 
@@ -228,17 +227,11 @@ def _set_distribution_options(self):
         # get backend coupling map and create coupling map for physical qubits converted
         # to qubits 0, 1...n
         if self.backend and self._backend_data.coupling_map:
-            coupling_map = self._backend_data.coupling_map
+            coupling_map = CouplingMap(self._backend_data.coupling_map)
         else:
-            coupling_map = list(itertools.permutations(range(max(self.physical_qubits) + 1), 2))
-        qmap = {self.physical_qubits[i]: i for i in range(len(self.physical_qubits))}
-        experiment_coupling_map = []
-
-        for edge in coupling_map:
-            if edge[0] in self.physical_qubits and edge[1] in self.physical_qubits:
-                experiment_coupling_map.append((qmap[edge[0]], qmap[edge[1]]))
+            coupling_map = CouplingMap.from_full(len(self.physical_qubits))
 
-        self._distribution.coupling_map = experiment_coupling_map
+        self._distribution.coupling_map = coupling_map.reduce(self.physical_qubits)
 
         # Adjust the density based on whether the pauli layers are in
         if self.experiment_options.pauli_randomize:
@@ -336,14 +329,11 @@ def _sample_sequences(self) -> List[Sequence[SequenceElementType]]:
 
                 # Add start and end cliffords if set by user
                 if self.experiment_options.start_end_clifford:
-                    cseq = []
                     clifford_layers = clifford_sampler(range(self.num_qubits), length=1)
-                    cseq.append(clifford_layers[0])
-                    cseq.extend(seq)
-                    cseq.append(self._inverse_layer(clifford_layers[0]))
+                    seq.insert(0, clifford_layers[0])
+                    seq.append(self._inverse_layer(clifford_layers[0]))
                     if not self.experiment_options.full_sampling:
                         build_seq_lengths = [length + 2 for length in build_seq_lengths]
-                    seq = cseq
 
                 if self.experiment_options.full_sampling:
                     sequences.append(seq)
@@ -381,8 +371,6 @@ def _sequences_to_circuits(
                 circ.append(Barrier(self.num_qubits), circ.qubits)
             circ.metadata = {
                 "xval": self.experiment_options.lengths[i % len(self.experiment_options.lengths)],
-                "group": "Clifford",
-                "physical_qubits": self.physical_qubits,
                 "target": compute_target_bitstring(circ_target),
                 "inverting_pauli_layer": self.experiment_options.inverting_pauli_layer,
             }

qiskit_experiments/library/randomized_benchmarking/sampling_utils.py

@@ -272,16 +272,19 @@ def __init__(
         """
         super().__init__(seed)
         self._gate_distribution = gate_distribution
-        self._coupling_map = coupling_map
+        self.coupling_map = coupling_map
 
     @property
-    def coupling_map(self):
+    def coupling_map(self) -> CouplingMap:
         """The coupling map of the system to sample over."""
         return self._coupling_map
 
     @coupling_map.setter
-    def coupling_map(self, coupling_map):
-        self._coupling_map = coupling_map
+    def coupling_map(self, coupling_map: Union[List[List[int]], CouplingMap]) -> None:
+        try:
+            self._coupling_map = CouplingMap(coupling_map)
+        except (ValueError, TypeError) as exc:
+            raise TypeError("Invalid coupling map provided.") from exc
 
     def __call__(
         self,
@@ -338,12 +341,12 @@ def __call__(
                 )
             ]
 
-        if not isinstance(self.coupling_map, List) or isinstance(self.coupling_map, CouplingMap):
-            raise QiskitError("The coupling map must be set correctly before sampling.")
-
         layer_list = []
+
         for _ in range(length):
-            all_edges = self.coupling_map[:]  # make copy of coupling map from which we pop edges
+            all_edges = self.coupling_map.get_edges()[
+                :
+            ]  # make copy of coupling map from which we pop edges
             selected_edges = []
             while all_edges:
                 rand_edge = all_edges.pop(self._rng.integers(len(all_edges)))

test/library/randomized_benchmarking/test_mirror_rb.py

@@ -635,7 +635,7 @@ def test_add_more_circuit_yields_lower_variance(self):
     )
     def test_invalid_configuration(self, configs):
         """Test raise error when creating experiment with invalid configs."""
-        self.assertRaises(QiskitError, rb.MirrorRB, **configs)
+        self.assertRaises((QiskitError, ValueError), rb.MirrorRB, **configs)
 
     @data(
         {