Update RB to reduce the size of the generated circuits

cirq-core/cirq/experiments/qubit_characterizations.py

@@ -36,6 +36,12 @@
     import cirq
 
 
+def _canonize_clifford_sequences(
+    sequences: list[list[ops.SingleQubitCliffordGate]],
+) -> list[list[ops.SingleQubitCliffordGate]]:
+    return [[_reduce_gate_seq(seq)] for seq in sequences]
+
+
 @dataclasses.dataclass
 class Cliffords:
     """The single-qubit Clifford group, decomposed into elementary gates.
@@ -336,7 +342,7 @@ def plot(
 def single_qubit_randomized_benchmarking(
     sampler: cirq.Sampler,
     qubit: cirq.Qid,
-    use_xy_basis: bool = True,
+    use_xy_basis: bool = False,
     *,
     num_clifford_range: Sequence[int] = tuple(np.logspace(np.log10(5), 3, 5, dtype=int)),
     num_circuits: int = 10,
@@ -387,16 +393,29 @@ def single_qubit_randomized_benchmarking(
     return result.results_dictionary[qubit]
 
 
+def _gateset_selector(
+    use_xy_basis: bool, xy_only: bool, xz_only: bool
+) -> list[list[ops.SingleQubitCliffordGate]]:
+    clifford_group = _single_qubit_cliffords()
+    sequences = clifford_group.c1_in_xy if use_xy_basis else clifford_group.c1_in_xz
+    filter_seq = lambda seq: len(seq) == 2
+    if xy_only or xz_only:
+        sequences = list(filter(filter_seq, sequences))
+    return _canonize_clifford_sequences(sequences)
+
+
 def parallel_single_qubit_randomized_benchmarking(
     sampler: cirq.Sampler,
     qubits: Sequence[cirq.Qid],
-    use_xy_basis: bool = True,
+    use_xy_basis: bool = False,
     *,
     num_clifford_range: Sequence[int] = tuple(
         np.logspace(np.log10(5), np.log10(1000), 5, dtype=int)
     ),
     num_circuits: int = 10,
     repetitions: int = 1000,
+    xy_only: bool = True,
+    xz_only: bool = False,
 ) -> ParallelRandomizedBenchmarkingResult:
     """Clifford-based randomized benchmarking (RB) single qubits in parallel.
 
@@ -413,13 +432,15 @@ def parallel_single_qubit_randomized_benchmarking(
         num_circuits: The number of random circuits generated for each
             number of Cliffords.
         repetitions: The number of repetitions of each circuit.
-
+        xy_only: whether to use only gates that have either an X or a Y component.
+            if True, this excludes I, Z, Z/2, -Z/2.
+        xz_only: whether to use only gates that have either an X or a Z component.
+            if True, this excludes I, Y, Y/2, -Y/2.
     Returns:
         A dictionary from qubits to RandomizedBenchMarkResult objects.
     """
 
-    clifford_group = _single_qubit_cliffords()
-    c1 = clifford_group.c1_in_xy if use_xy_basis else clifford_group.c1_in_xz
+    c1 = _gateset_selector(use_xy_basis, xy_only, xz_only)
 
     # create circuits
     circuits_all: list[cirq.AbstractCircuit] = []
@@ -677,7 +698,7 @@ def _measurement(two_qubit_circuit: circuits.Circuit) -> np.ndarray:
 
 
 def _create_parallel_rb_circuit(
-    qubits: Sequence[cirq.Qid], num_cliffords: int, c1: list
+    qubits: Sequence[cirq.Qid], num_cliffords: int, c1: list[list[ops.SingleQubitCliffordGate]]
 ) -> cirq.Circuit:
     sequences_to_zip = [_random_single_q_clifford(qubit, num_cliffords, c1) for qubit in qubits]
     # Ensure each sequence has the same number of moments.
@@ -732,9 +753,8 @@ def _two_qubit_clifford_matrices(q_0: cirq.Qid, q_1: cirq.Qid, cliffords: Cliffo
 def _random_single_q_clifford(
     qubit: cirq.Qid, num_cfds: int, cfds: Sequence[Sequence[cirq.ops.SingleQubitCliffordGate]]
 ) -> list[cirq.Operation]:
-    clifford_group_size = 24
     operations = [[gate.to_phased_xz_gate()(qubit) for gate in gates] for gates in cfds]
-    gate_ids = np.random.choice(clifford_group_size, num_cfds).tolist()
+    gate_ids = np.random.choice(len(cfds), num_cfds).tolist()
     adjoint = _reduce_gate_seq([gate for gate_id in gate_ids for gate in cfds[gate_id]]) ** -1
     return [op for gate_id in gate_ids for op in operations[gate_id]] + [
         adjoint.to_phased_xz_gate()(qubit)

cirq-core/cirq/experiments/qubit_characterizations_test.py

@@ -229,13 +229,21 @@ def test_tomography_plot_raises_for_incorrect_number_of_axes():
         result.plot(axes)
 
 
-def test_single_qubit_cliffords_gateset():
+@pytest.mark.parametrize('num_cliffords', range(5, 10))
+@pytest.mark.parametrize('use_xy_basis', [False, True])
+@pytest.mark.parametrize('xy_only', [False, True])
+@pytest.mark.parametrize('xz_only', [False, True])
+def test_single_qubit_cliffords_gateset(num_cliffords, use_xy_basis, xy_only, xz_only):
     qubits = [GridQubit(0, i) for i in range(4)]
-    clifford_group = cirq.experiments.qubit_characterizations._single_qubit_cliffords()
+    c1_in_xy = cirq.experiments.qubit_characterizations._gateset_selector(
+        use_xy_basis, xy_only, xz_only
+    )
     c = cirq.experiments.qubit_characterizations._create_parallel_rb_circuit(
-        qubits, 5, clifford_group.c1_in_xy
+        qubits, num_cliffords, c1_in_xy
     )
     device = cirq.testing.ValidatingTestDevice(
         qubits=qubits, allowed_gates=(cirq.ops.PhasedXZGate, cirq.MeasurementGate)
     )
     device.validate_circuit(c)
+
+    assert len(c) == num_cliffords + 2