optimize clifford benchmark circuit creation for a total 94.5% speedup (#6401)

This is a followup to #6392 and reduces circuit creation time (for 1000 cliffords and 50 qubits) to 0.213s from the original 3.886s (94.5% speedup) and the 2.148s (90% speedup) following #6392

```
In [3]: import cirq.experiments.qubit_characterizations as ceq
   ...: import cirq
   ...: import time
   ...: import numpy as np
   ...: 
   ...: num_cliffords = 1000
   ...: qubits = cirq.LineQubit.range(50)
   ...: 
   ...: cliffords = ceq._single_qubit_cliffords()
   ...: c1 = cliffords.c1_in_xy
   ...: t1 = time.time()
   ...: seq = ceq._create_parallel_rb_circuit(qubits, num_cliffords, c1)
   ...: t2 = time.time()
   ...: print(f'{t2-t1} s')
0.2055680751800537 s
```

Author: NoureldinYosri

cirq-core/cirq/experiments/qubit_characterizations.py

@@ -257,10 +257,9 @@ def single_qubit_randomized_benchmarking(
         A RandomizedBenchMarkResult object that stores and plots the result.
     """
 
-    qubits = cast(Iterator['cirq.Qid'], (qubit,))
     result = parallel_single_qubit_randomized_benchmarking(
         sampler,
-        qubits,
+        (qubit,),
         use_xy_basis,
         num_clifford_range=num_clifford_range,
         num_circuits=num_circuits,
@@ -271,7 +270,7 @@ def single_qubit_randomized_benchmarking(
 
 def parallel_single_qubit_randomized_benchmarking(
     sampler: 'cirq.Sampler',
-    qubits: Iterator['cirq.Qid'],
+    qubits: Sequence['cirq.Qid'],
     use_xy_basis: bool = True,
     *,
     num_clifford_range: Sequence[int] = tuple(
@@ -560,11 +559,16 @@ def _measurement(two_qubit_circuit: circuits.Circuit) -> np.ndarray:
 
 
 def _create_parallel_rb_circuit(
-    qubits: Iterator['cirq.Qid'], num_cliffords: int, c1: list
+    qubits: Sequence['cirq.Qid'], num_cliffords: int, c1: list
 ) -> 'cirq.Circuit':
-    circuits_to_zip = [_random_single_q_clifford(qubit, num_cliffords, c1) for qubit in qubits]
-    circuit = circuits.Circuit.zip(*circuits_to_zip)
-    return circuits.Circuit.from_moments(*circuit, ops.measure_each(*qubits))
+    sequences_to_zip = [_random_single_q_clifford(qubit, num_cliffords, c1) for qubit in qubits]
+    # Ensure each sequence has the same number of moments.
+    num_moments = max(len(sequence) for sequence in sequences_to_zip)
+    for q, sequence in zip(qubits, sequences_to_zip):
+        if (n := len(sequence)) < num_moments:
+            sequence.extend([ops.SingleQubitCliffordGate.I(q)] * (num_moments - n))
+    moments = zip(*sequences_to_zip)
+    return circuits.Circuit.from_moments(*moments, ops.measure_each(*qubits))
 
 
 def _indices_after_basis_rot(i: int, j: int) -> Tuple[int, Sequence[int], Sequence[int]]:
@@ -609,13 +613,12 @@ def _two_qubit_clifford_matrices(
 
 def _random_single_q_clifford(
     qubit: 'cirq.Qid', num_cfds: int, cfds: Sequence[Sequence['cirq.Gate']]
-) -> 'cirq.Circuit':
+) -> List['cirq.Operation']:
     clifford_group_size = 24
+    operations = [[gate(qubit) for gate in gates] for gates in cfds]
     gate_ids = list(np.random.choice(clifford_group_size, num_cfds))
-    gate_sequence = [gate for gate_id in gate_ids for gate in cfds[gate_id]]
-    gate_sequence.append(_reduce_gate_seq(gate_sequence) ** -1)
-    circuit = circuits.Circuit(gate(qubit) for gate in gate_sequence)
-    return circuit
+    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(qubit)]
 
 
 def _random_two_q_clifford(

cirq-core/cirq/sim/clifford/clifford_simulator_test.py

@@ -324,9 +324,11 @@ def test_clifford_circuit_SHSYSHS():
     clifford_simulator = cirq.CliffordSimulator()
     state_vector_simulator = cirq.Simulator()
 
+    # workaround until #6402 is resolved.
+    final_state_vector = state_vector_simulator.simulate(circuit).final_state_vector
+    final_state_vector /= np.sqrt(np.linalg.norm(final_state_vector))
     np.testing.assert_almost_equal(
-        clifford_simulator.simulate(circuit).final_state.state_vector(),
-        state_vector_simulator.simulate(circuit).final_state_vector,
+        clifford_simulator.simulate(circuit).final_state.state_vector(), final_state_vector
     )