cirq-core 1.5.0.dev20250409225226__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/transformers/merge_single_qubit_gates_test.py

@@ -12,14 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List
+from unittest import TestCase
+from unittest.mock import Mock, patch
+
+import pytest
+import sympy
 
 import cirq
 
 
 def assert_optimizes(optimized: cirq.AbstractCircuit, expected: cirq.AbstractCircuit):
     # Ignore differences that would be caught by follow-up optimizations.
-    followup_transformers: List[cirq.TRANSFORMER] = [
+    followup_transformers: list[cirq.TRANSFORMER] = [
         cirq.drop_negligible_operations,
         cirq.drop_empty_moments,
     ]
@@ -81,7 +85,7 @@ def test_merge_single_qubit_gates_to_phased_x_and_z_deep():
     cirq.testing.assert_same_circuits(c_new, c_expected)
 
 
-def _phxz(a: float, x: float, z: float):
+def _phxz(a: float | sympy.Symbol, x: float | sympy.Symbol, z: float | sympy.Symbol):
     return cirq.PhasedXZGate(axis_phase_exponent=a, x_exponent=x, z_exponent=z)
 
 
@@ -221,13 +225,181 @@ def test_merge_single_qubit_moments_to_phxz_deep():
     )
 
 
-def test_merge_single_qubit_moments_to_phxz_global_phase():
+def test_merge_single_qubit_gates_to_phxz_global_phase():
     c = cirq.Circuit(cirq.GlobalPhaseGate(1j).on())
     c2 = cirq.merge_single_qubit_gates_to_phxz(c)
     assert c == c2
 
 
-def test_merge_single_qubit_moments_to_phased_x_and_z_global_phase():
+def test_merge_single_qubit_gates_to_phased_x_and_z_global_phase():
     c = cirq.Circuit(cirq.GlobalPhaseGate(1j).on())
     c2 = cirq.merge_single_qubit_gates_to_phased_x_and_z(c)
     assert c == c2
+
+
+class TestMergeSingleQubitGatesSymbolized(TestCase):
+    """Test suite for merge_single_qubit_gates_to_phxz_symbolized."""
+
+    def test_case1(self):
+        """Test case diagram.
+        Input circuit:
+        0: ───X─────────@────────H[ignore]─H──X──PhXZ(a=a0,x=x0,z=z0)──X──PhXZ(a=a1,x=x1,z=z1)───
+                        │
+        1: ───H^h_exp───@^cz_exp─────────────────────────────────────────────────────────────────
+        Expected output:
+        0: ───PhXZ(a=-1,x=1,z=0)─────@──────────H[ignore]───PhXZ(a=a1,x=x1,z=z1)───
+                                     │
+        1: ───PhXZ(a=a0,x=x0,z=z0)───@^cz_exp──────────────────────────────────────
+        """
+        a, b = cirq.LineQubit.range(2)
+        sa0, sa1 = [sympy.Symbol(a) for a in ["a0", "a1"]]
+        sx0, sx1 = [sympy.Symbol(x) for x in ["x0", "x1"]]
+        sz0, sz1 = [sympy.Symbol(z) for z in ["z0", "z1"]]
+        input_circuit = cirq.Circuit(
+            cirq.Moment(cirq.X(a), cirq.H(b) ** sympy.Symbol("h_exp")),
+            cirq.Moment(cirq.CZ(a, b) ** sympy.Symbol("cz_exp")),
+            cirq.Moment(cirq.H(a).with_tags("ignore")),
+            cirq.Moment(cirq.H(a)),
+            cirq.Moment(cirq.X(a)),
+            cirq.Moment(_phxz(sa0, sx0, sz0).on(a)),
+            cirq.Moment(cirq.X(a)),
+            cirq.Moment(_phxz(sa1, sx1, sz1).on(a)),
+        )
+        context = cirq.TransformerContext(tags_to_ignore=["ignore"])
+        sweep = cirq.Zip(
+            cirq.Points(key="h_exp", points=[0, 1]),
+            cirq.Points(key="cz_exp", points=[0, 1]),
+            cirq.Points(key="a0", points=[0, 1]),
+            cirq.Points(key="x0", points=[0, 1]),
+            cirq.Points(key="z0", points=[0, 1]),
+            cirq.Points(key="a1", points=[0, 1]),
+            cirq.Points(key="x1", points=[0, 1]),
+            cirq.Points(key="z1", points=[0, 1]),
+        )
+        output_circuit, new_sweep = cirq.merge_single_qubit_gates_to_phxz_symbolized(
+            input_circuit, context=context, sweep=sweep
+        )
+        expected = cirq.Circuit(
+            cirq.Moment(_phxz(-1, 1, 0).on(a), _phxz(sa0, sx0, sz0).on(b)),
+            cirq.Moment(cirq.CZ(a, b) ** sympy.Symbol("cz_exp")),
+            cirq.Moment(cirq.H(a).with_tags("ignore")),
+            cirq.Moment(_phxz(sa1, sx1, sz1).on(a)),
+        )
+        assert_optimizes(output_circuit, expected)
+
+        # Check the unitaries are preserved for each set of sweep parameterization.
+        for old_resolver, new_resolver in zip(sweep, new_sweep):
+            cirq.testing.assert_circuits_have_same_unitary_given_final_permutation(
+                cirq.resolve_parameters(input_circuit, old_resolver),
+                cirq.resolve_parameters(output_circuit, new_resolver),
+                {q: q for q in input_circuit.all_qubits()},
+            )
+
+    def test_with_gauge_compiling_as_sweep_success(self):
+        qubits = cirq.LineQubit.range(7)
+        c = cirq.Circuit(
+            cirq.Moment(cirq.H(qubits[0]), cirq.H(qubits[3])),
+            cirq.Moment(cirq.CZ(qubits[0], qubits[2]), cirq.CZ(qubits[3], qubits[5])),
+            cirq.Moment(cirq.CZ(qubits[0], qubits[1]), cirq.CZ(qubits[3], qubits[4])),
+            cirq.Moment(cirq.CZ(qubits[1], qubits[3]), cirq.CZ(qubits[4], qubits[6])),
+            cirq.Moment(cirq.M(*qubits, key='m')),
+        )
+        old_circuit, old_sweep = cirq.transformers.gauge_compiling.CZGaugeTransformer.as_sweep(
+            c, N=50
+        )
+        new_circuit, new_sweep = cirq.merge_single_qubit_gates_to_phxz_symbolized(
+            old_circuit, sweep=old_sweep
+        )
+        # Check the unitaries are preserved for each set of sweep parameterization.
+        for old_resolver, new_resolver in zip(old_sweep, new_sweep):
+            cirq.testing.assert_circuits_have_same_unitary_given_final_permutation(
+                cirq.resolve_parameters(old_circuit[0:-1], old_resolver),
+                cirq.resolve_parameters(new_circuit[0:-1], new_resolver),
+                {q: q for q in qubits},
+            )
+
+    def test_case_non_parameterized_singles(self):
+        """Test merge_single_qubit_gates_to_phxz_symbolized when all single qubit gates are not
+        parameterized."""
+
+        a, b = cirq.LineQubit.range(2)
+        input_circuit = cirq.Circuit(cirq.H(a), cirq.H(a), cirq.CZ(a, b) ** sympy.Symbol("exp"))
+        expected_circuit = cirq.merge_single_qubit_gates_to_phxz(input_circuit)
+        output_circuit, _ = cirq.merge_single_qubit_gates_to_phxz_symbolized(
+            input_circuit, sweep=cirq.Points(key="exp", points=[0.1, 0.2, 0.5])
+        )
+        assert_optimizes(output_circuit, expected_circuit)
+
+    def test_fail_different_structures_error(self):
+        """Tests that the function raises a ValueError if merged structures of the circuit differ
+        for different parameterizations."""
+        q0, q1 = cirq.LineQubit.range(2)
+        circuit = cirq.Circuit(cirq.H(q0) ** sympy.Symbol("exp"))
+        sweep = cirq.Points(key="exp", points=[0.1, 0.2])
+
+        with patch(
+            "cirq.protocols.resolve_parameters",
+            side_effect=[  # Mock the return values of resolve_parameters
+                cirq.Circuit(cirq.I(q0).with_tags("_tmp_symbolize_tag")),
+                cirq.Circuit(cirq.CZ(q0, q1)),
+            ],
+        ):
+            with pytest.raises(ValueError, match="Expect a PhasedXZGate or IdentityGate.*"):
+                cirq.merge_single_qubit_gates_to_phxz_symbolized(circuit, sweep=sweep)
+
+    def test_fail_unexpected_gate_error(self):
+        """Tests that the function raises a RuntimeError of unexpected gate."""
+        a, b = cirq.LineQubit.range(2)
+        circuit = cirq.Circuit(
+            cirq.H(a) ** sympy.Symbol("exp1"),
+            cirq.X(a),
+            cirq.CZ(a, b),
+            cirq.Y(a),
+            cirq.H(a) ** sympy.Symbol("exp2"),
+        )
+        sweep = cirq.Points(key="exp1", points=[0.1, 0.2]) * cirq.Points(
+            key="exp2", points=[0.1, 0.2]
+        )
+
+        mock_iter = Mock()
+        mock_iter.__next__ = Mock(return_value=2)
+
+        with patch(
+            "cirq.transformers.analytical_decompositions"
+            ".single_qubit_decompositions.single_qubit_matrix_to_phxz",
+            return_value=cirq.H,
+        ):
+            with pytest.raises(ValueError, match="Expect a PhasedXZGate or IdentityGate.*"):
+                cirq.merge_single_qubit_gates_to_phxz_symbolized(circuit, sweep=sweep)
+
+
+def test_merge_single_qubit_moments_to_phxz_with_global_phase_in_first_moment():
+    q0 = cirq.LineQubit(0)
+    c_orig = cirq.Circuit(
+        cirq.Moment(cirq.Y(q0) ** 0.5, cirq.GlobalPhaseGate(1j**0.5).on()), cirq.Moment(cirq.X(q0))
+    )
+    c_expected = cirq.Circuit(
+        cirq.Moment(
+            cirq.PhasedXZGate(axis_phase_exponent=-0.5, x_exponent=0.5, z_exponent=-1.0).on(q0),
+            cirq.GlobalPhaseGate(1j**0.5).on(),
+        )
+    )
+    context = cirq.TransformerContext(tags_to_ignore=["ignore"])
+    c_new = cirq.merge_single_qubit_moments_to_phxz(c_orig, context=context)
+    assert c_new == c_expected
+
+
+def test_merge_single_qubit_moments_to_phxz_with_global_phase_in_second_moment():
+    q0 = cirq.LineQubit(0)
+    c_orig = cirq.Circuit(
+        cirq.Moment(cirq.Y(q0) ** 0.5), cirq.Moment(cirq.X(q0), cirq.GlobalPhaseGate(1j**0.5).on())
+    )
+    c_expected = cirq.Circuit(
+        cirq.Moment(
+            cirq.PhasedXZGate(axis_phase_exponent=-0.5, x_exponent=0.5, z_exponent=-1.0).on(q0),
+            cirq.GlobalPhaseGate(1j**0.5).on(),
+        )
+    )
+    context = cirq.TransformerContext(tags_to_ignore=["ignore"])
+    c_new = cirq.merge_single_qubit_moments_to_phxz(c_orig, context=context)
+    assert c_new == c_expected

cirq/transformers/noise_adding.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from collections.abc import Mapping
 from typing import cast
 
@@ -34,7 +36,7 @@ class DepolarizingNoiseTransformer:
 
     Attrs:
         p: The probability with which to add noise.
-        target_gate: Add depolarizing nose after this type of gate
+        target_gate: Add depolarizing noise after this type of gate
     """
 
     def __init__(
@@ -56,7 +58,7 @@ class DepolarizingNoiseTransformer:
         if not isinstance(p, (Mapping, float)):
             raise TypeError(  # pragma: no cover
                 "p must either be a float or a mapping from"  # pragma: no cover
-                + "sorted qubit pairs to floats"  # pragma: no cover
+                "sorted qubit pairs to floats"  # pragma: no cover
             )  # pragma: no cover
         self.p = p
         self.p_func = (
@@ -86,7 +88,7 @@ class DepolarizingNoiseTransformer:
             rng = np.random.default_rng()
         target_gate = self.target_gate
 
-        # add random Pauli gates with probability p after each of the specified gate
+        # add random Pauli gates with probability p after each specified gate
         assert target_gate.num_qubits() == 2, "`target_gate` must be a two-qubit gate."
         paulis = [ops.I, ops.X, ops.Y, ops.Z]
         new_moments = []

cirq/transformers/noise_adding_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 
 import cirq.transformers.noise_adding as na

cirq/transformers/optimize_for_target_gateset.py

@@ -14,7 +14,9 @@
 
 """Transformers to rewrite a circuit using gates from a given target gateset."""
 
-from typing import Callable, Hashable, Optional, Sequence, TYPE_CHECKING, Union
+from __future__ import annotations
+
+from typing import Callable, Hashable, Sequence, TYPE_CHECKING
 
 from cirq import circuits
 from cirq.protocols import decompose_protocol as dp
@@ -24,8 +26,8 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _create_on_stuck_raise_error(gateset: 'cirq.Gateset'):
-    def _value_error_describing_bad_operation(op: 'cirq.Operation') -> ValueError:
+def _create_on_stuck_raise_error(gateset: cirq.Gateset):
+    def _value_error_describing_bad_operation(op: cirq.Operation) -> ValueError:
         return ValueError(f"Unable to convert {op} to target gateset {gateset!r}")
 
     return _value_error_describing_bad_operation
@@ -33,20 +35,20 @@ def _create_on_stuck_raise_error(gateset: 'cirq.Gateset'):
 
 @transformer_api.transformer
 def _decompose_operations_to_target_gateset(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
-    gateset: Optional['cirq.Gateset'] = None,
-    decomposer: Callable[['cirq.Operation', int], dp.DecomposeResult] = lambda *_: NotImplemented,
+    context: cirq.TransformerContext | None = None,
+    gateset: cirq.Gateset | None = None,
+    decomposer: Callable[[cirq.Operation, int], dp.DecomposeResult] = lambda *_: NotImplemented,
     ignore_failures: bool = True,
     tags_to_decompose: Sequence[Hashable] = (),
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Decomposes every operation to `gateset` using `cirq.decompose` and `decomposer`.
 
     This transformer attempts to decompose every operation `op` in the given circuit to `gateset`
-    using `cirq.decompose` protocol with `decomposer` used as an intercepting decomposer. This
-    ensures that `op` is recursively decomposed using implicitly defined known decompositions
-    (eg: in `_decompose_` magic method on the gaet class) till either `decomposer` knows how to
+    using the `cirq.decompose` protocol with `decomposer` used as an intercepting decomposer. This
+    ensures that `op` is recursively decomposed using implicitly defined known decompositions (e.g.
+    in the `_decompose_` magic method on the gate class) until either `decomposer` knows how to
     decompose the given operation or the given operation belongs to `gateset`.
 
     Args:
@@ -68,7 +70,7 @@ def _decompose_operations_to_target_gateset(
         ValueError: If any input operation fails to convert and `ignore_failures` is False.
     """
 
-    def map_func(op: 'cirq.Operation', moment_index: int):
+    def map_func(op: cirq.Operation, moment_index: int):
         if (
             context
             and context.deep
@@ -97,13 +99,13 @@ def _decompose_operations_to_target_gateset(
 
 @transformer_api.transformer
 def optimize_for_target_gateset(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
-    gateset: Optional['cirq.CompilationTargetGateset'] = None,
+    context: cirq.TransformerContext | None = None,
+    gateset: cirq.CompilationTargetGateset | None = None,
     ignore_failures: bool = True,
-    max_num_passes: Union[int, None] = 1,
-) -> 'cirq.Circuit':
+    max_num_passes: int | None = 1,
+) -> cirq.Circuit:
     """Transforms the given circuit into an equivalent circuit using gates accepted by `gateset`.
 
     Repeat max_num_passes times or when `max_num_passes=None` until no further changes can be done

cirq/transformers/optimize_for_target_gateset_test.py

@@ -12,14 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 import pytest
 
 import cirq
-from cirq.protocols.decompose_protocol import DecomposeResult
 from cirq.transformers.optimize_for_target_gateset import _decompose_operations_to_target_gateset
 
+if TYPE_CHECKING:
+    from cirq.protocols.decompose_protocol import DecomposeResult
+
 
 def test_decompose_operations_raises_on_stuck():
     c_orig = cirq.Circuit(cirq.X(cirq.NamedQubit("q")).with_tags("ignore"))
@@ -37,7 +41,6 @@ def test_decompose_operations_raises_on_stuck():
     cirq.testing.assert_same_circuits(c_orig, c_new)
 
 
-# pylint: disable=line-too-long
 def test_decompose_operations_to_target_gateset_default():
     q = cirq.LineQubit.range(2)
     c_orig = cirq.Circuit(
@@ -70,7 +73,7 @@ m: ═════════════════════════
 1: ───────Y^-0.5───@───Y^0.5────@───Y^-0.5───@───Y^0.5───────×───────────╫───X───T───Y^-0.5───@───Y^0.5────@───Y^-0.5───@───Y^0.5───T───
                                                                          ║   ║
 m: ══════════════════════════════════════════════════════════════════════@═══^══════════════════════════════════════════════════════════
-''',
+''',  # noqa: E501
     )
 
 
@@ -121,7 +124,7 @@ class MatrixGateTargetGateset(cirq.CompilationTargetGateset):
     def num_qubits(self) -> int:
         return 2
 
-    def decompose_to_target_gateset(self, op: 'cirq.Operation', _) -> DecomposeResult:
+    def decompose_to_target_gateset(self, op: cirq.Operation, _) -> DecomposeResult:
         if cirq.num_qubits(op) != 2 or not cirq.has_unitary(op):
             return NotImplemented
         return cirq.MatrixGate(cirq.unitary(op), name="M").on(*op.qubits)
@@ -188,7 +191,7 @@ m: ═════════════════════@═══^═
                                                                   ║   ║
 m: ═══════════════════════════════════════════════════════════════@═══^═════════════════════════════════════════════════════════
                                          └────────┘                       └────────┘                 └────────┘
-       ''',
+       ''',  # noqa: E501
     )
 
     with pytest.raises(ValueError, match="Unable to convert"):
@@ -249,7 +252,7 @@ def test_optimize_for_target_gateset_deep():
 
 
 @pytest.mark.parametrize('max_num_passes', [2, None])
-def test_optimize_for_target_gateset_multiple_passes(max_num_passes: Union[int, None]):
+def test_optimize_for_target_gateset_multiple_passes(max_num_passes: int | None):
     gateset = cirq.CZTargetGateset()
 
     input_circuit = cirq.Circuit(
@@ -328,7 +331,7 @@ def test_optimize_for_target_gateset_multiple_passes(max_num_passes: Union[int,
 
 @pytest.mark.parametrize('max_num_passes', [2, None])
 def test_optimize_for_target_gateset_multiple_passes_dont_preserve_moment_structure(
-    max_num_passes: Union[int, None],
+    max_num_passes: int | None,
 ):
     gateset = cirq.CZTargetGateset(preserve_moment_structure=False)
 

cirq/transformers/qubit_management_transformers.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict, Optional, Set, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 from cirq import circuits, ops
 
@@ -21,8 +23,8 @@ if TYPE_CHECKING:
 
 
 def _get_qubit_mapping_first_and_last_moment(
-    circuit: 'cirq.AbstractCircuit',
-) -> Dict['cirq.Qid', Tuple[int, int]]:
+    circuit: cirq.AbstractCircuit,
+) -> dict[cirq.Qid, tuple[int, int]]:
     """Computes `(first_moment_idx, last_moment_idx)` tuple for each qubit in the input circuit.
 
     Args:
@@ -41,13 +43,13 @@ def _get_qubit_mapping_first_and_last_moment(
     return ret
 
 
-def _is_temp(q: 'cirq.Qid') -> bool:
+def _is_temp(q: cirq.Qid) -> bool:
     return isinstance(q, (ops.CleanQubit, ops.BorrowableQubit))
 
 
 def map_clean_and_borrowable_qubits(
-    circuit: 'cirq.AbstractCircuit', *, qm: Optional['cirq.QubitManager'] = None
-) -> 'cirq.Circuit':
+    circuit: cirq.AbstractCircuit, *, qm: cirq.QubitManager | None = None
+) -> cirq.Circuit:
     """Uses `qm: QubitManager` to map all `CleanQubit`/`BorrowableQubit`s to system qubits.
 
     `CleanQubit` and `BorrowableQubit` are internal qubit types that are used as placeholder qubits
@@ -56,7 +58,7 @@ def map_clean_and_borrowable_qubits(
     This transformer uses the `QubitManager` provided in the input to:
      - Allocate clean ancilla qubits by delegating to `qm.qalloc` for all `CleanQubit`s.
      - Allocate dirty qubits for all `BorrowableQubit` types via the following two steps:
-         1. First analyse the input circuit and check if there are any suitable system qubits
+         1. First analyze the input circuit and check if there are any suitable system qubits
             that can be borrowed, i.e. ones which do not have any overlapping operations
             between circuit[start_index : end_index] where `(start_index, end_index)` is the
             lifespan of temporary borrowable qubit under consideration. If yes, borrow the system
@@ -82,7 +84,7 @@ def map_clean_and_borrowable_qubits(
         circuit: Input `cirq.Circuit` containing temporarily allocated
             `CleanQubit`/`BorrowableQubit`s.
         qm: An instance of `cirq.QubitManager` specifying the strategy to use for allocating /
-            / deallocating new ancilla qubits to replace the temporary qubits.
+            deallocating new ancilla qubits to replace the temporary qubits.
 
     Returns:
         An updated `cirq.Circuit` with all `CleanQubit`/`BorrowableQubit` mapped to either existing
@@ -97,11 +99,11 @@ def map_clean_and_borrowable_qubits(
     trivial_map = {q: q for q in all_qubits}
     # `allocated_map` maintains the mapping of all temporary qubits seen so far, mapping each of
     # them to either a newly allocated managed ancilla or an existing borrowed system qubit.
-    allocated_map: Dict['cirq.Qid', 'cirq.Qid'] = {}
-    to_free: Set['cirq.Qid'] = set()
+    allocated_map: dict[cirq.Qid, cirq.Qid] = {}
+    to_free: set[cirq.Qid] = set()
     last_op_idx = -1
 
-    def map_func(op: 'cirq.Operation', idx: int) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, idx: int) -> cirq.OP_TREE:
         nonlocal last_op_idx, to_free
         assert isinstance(qm, ops.QubitManager)
 

cirq/transformers/qubit_management_transformers_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 
 
@@ -66,7 +68,7 @@ def get_decompose_func(gate_type, qm):
     return decompose_func
 
 
-def test_map_clean_and_borrowable_qubits_greedy_types():
+def test_map_clean_and_borrowable_qubits_greedy_types() -> None:
     qm = cirq.ops.SimpleQubitManager()
     q = cirq.LineQubit.range(2)
     g = GateAllocInDecompose(1)
@@ -130,7 +132,7 @@ ancilla_1: ───X───X───
     )
 
 
-def test_map_clean_and_borrowable_qubits_borrows():
+def test_map_clean_and_borrowable_qubits_borrows() -> None:
     qm = cirq.ops.SimpleQubitManager()
     op = GateAllocAndBorrowInDecompose(3).on(cirq.NamedQubit("original"))
     extra = cirq.LineQubit.range(3)
@@ -233,7 +235,7 @@ original: ────@───@───@───@─────@───@
     )
 
 
-def test_map_clean_and_borrowable_qubits_deallocates_only_once():
+def test_map_clean_and_borrowable_qubits_deallocates_only_once() -> None:
     q = [cirq.ops.BorrowableQubit(i) for i in range(2)] + [cirq.q('q')]
     circuit = cirq.Circuit(cirq.X.on_each(*q), cirq.Y(q[1]), cirq.Z(q[1]))
     greedy_mm = cirq.GreedyQubitManager(prefix="a", size=2)

cirq/transformers/randomized_measurements.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from collections.abc import Sequence
 from typing import Any
 
@@ -32,23 +34,23 @@ class RandomizedMeasurements:
         For more details on the randomized measurement toolbox see https://arxiv.org/abs/2203.11374
 
         Args:
-            subsystem: The specific subsystem (e.g qubit index) to measure in random basis
-            rest of the qubits are measured in the computational basis
+            subsystem: The specific subsystem (e.g., qubit index) to measure in a random basis.
+                The rest of the qubits are measured in the computational basis.
         """
         self.subsystem = subsystem
 
     def __call__(
         self,
-        circuit: "cirq.AbstractCircuit",
+        circuit: cirq.AbstractCircuit,
         unitary_ensemble: str = "pauli",
         rng: np.random.Generator | None = None,
         *,
         context: transformer_api.TransformerContext | None = None,
-    ) -> "cirq.Circuit":
+    ) -> cirq.Circuit:
         """Apply the transformer to the given circuit. Given an input circuit returns
-        a new circuit with the pre-measurement unitaries and measurements gates added.
-        to the qubits in the subsystem provided.If no subsystem is specified in the
-        construction of this class it defaults to measuring all the qubits in the
+        a new circuit with the pre-measurement unitaries and measurement gates added
+        to the qubits in the subsystem provided. If no subsystem is specified in the
+        construction of this class, it defaults to measuring all the qubits in the
         randomized bases.
 
         Args:
@@ -80,7 +82,7 @@ class RandomizedMeasurements:
 
     def random_single_qubit_unitary_moment(
         self, unitary_ensemble: str, qubits: Sequence[Any], rng: np.random.Generator
-    ) -> "cirq.Moment":
+    ) -> cirq.Moment:
         """Outputs the cirq moment associated with the pre-measurement rotations.
 
         Args:
@@ -115,7 +117,7 @@ class RandomizedMeasurements:
         return cirq.Moment.from_ops(*op_list)
 
 
-def _pauli_basis_rotation(rng: np.random.Generator) -> "cirq.Gate":
+def _pauli_basis_rotation(rng: np.random.Generator) -> cirq.Gate:
     """Randomly generate a Pauli basis rotation.
 
     Args:
@@ -127,7 +129,7 @@ def _pauli_basis_rotation(rng: np.random.Generator) -> "cirq.Gate":
     basis_idx = rng.choice(np.arange(3))
 
     if basis_idx == 0:
-        gate: "cirq.Gate" = cirq.Ry(rads=-np.pi / 2)
+        gate: cirq.Gate = cirq.Ry(rads=-np.pi / 2)
     elif basis_idx == 1:
         gate = cirq.Rx(rads=np.pi / 2)
     else:
@@ -135,8 +137,8 @@ def _pauli_basis_rotation(rng: np.random.Generator) -> "cirq.Gate":
     return gate
 
 
-def _single_qubit_clifford(rng: np.random.Generator) -> "cirq.Gate":
-    """Randomly generate a single-qubit Clifford rotation.
+def _single_qubit_clifford(rng: np.random.Generator) -> cirq.Gate:
+    """Randomly generates a single-qubit Clifford rotation.
 
     Args:
         rng: Random number generator
@@ -153,8 +155,8 @@ def _single_qubit_clifford(rng: np.random.Generator) -> "cirq.Gate":
     )
 
 
-def _single_qubit_cue(rng: np.random.Generator) -> "cirq.Gate":
-    """Randomly generate a CUE gate.
+def _single_qubit_cue(rng: np.random.Generator) -> cirq.Gate:
+    """Randomly generates a CUE gate.
 
     Args:
         rng: Random number generator

cirq/transformers/randomized_measurements_test.py

@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq
 import cirq.transformers.randomized_measurements as rand_meas
 
 
-def test_randomized_measurements_appends_two_moments_on_returned_circuit():
+def test_randomized_measurements_appends_two_moments_on_returned_circuit() -> None:
     # Create a 4-qubit circuit
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     circuit_pre = cirq.Circuit(
@@ -34,7 +36,9 @@ def test_randomized_measurements_appends_two_moments_on_returned_circuit():
         assert num_moments_post == num_moments_pre + 2
 
 
-def test_append_randomized_measurements_leaves_qubits_not_in_specified_subsystem_unchanged():
+def test_append_randomized_measurements_leaves_qubits_not_in_specified_subsystem_unchanged() -> (
+    None
+):
     # Create a 4-qubit circuit
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     circuit = cirq.Circuit([cirq.H(q0), cirq.CNOT(q0, q1), cirq.CNOT(q1, q2), cirq.CNOT(q2, q3)])
@@ -46,7 +50,9 @@ def test_append_randomized_measurements_leaves_qubits_not_in_specified_subsystem
     assert circuit.operation_at(q3, 4) is None
 
 
-def test_append_randomized_measurements_leaves_qubits_not_in_noncontinuous_subsystem_unchanged():
+def test_append_random_measurements_leaves_qubits_not_in_noncontinuous_subsystem_unchanged() -> (
+    None
+):
     # Create a 4-qubit circuit
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     circuit = cirq.Circuit([cirq.H(q0), cirq.CNOT(q0, q1), cirq.CNOT(q1, q2), cirq.CNOT(q2, q3)])
@@ -59,7 +65,7 @@ def test_append_randomized_measurements_leaves_qubits_not_in_noncontinuous_subsy
     assert circuit.operation_at(q3, 4) is None
 
 
-def test_exception():
+def test_exception() -> None:
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     circuit = cirq.Circuit([cirq.H(q0), cirq.CNOT(q0, q1), cirq.CNOT(q1, q2), cirq.CNOT(q2, q3)])