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

cirq/transformers/gauge_compiling/gauge_compiling.py

@@ -14,12 +14,14 @@
 
 """Creates the abstraction for gauge compiling as a cirq transformer."""
 
+from __future__ import annotations
+
 import abc
 import functools
 import itertools
 from dataclasses import dataclass
 from numbers import Real
-from typing import Callable, Dict, List, Optional, Sequence, Tuple, Union
+from typing import Callable, Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -28,11 +30,13 @@ from attrs import field, frozen
 from cirq import circuits, ops
 from cirq.protocols import unitary_protocol
 from cirq.protocols.has_unitary_protocol import has_unitary
-from cirq.study import sweepable
 from cirq.study.sweeps import Points, Zip
 from cirq.transformers import transformer_api
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions
 
+if TYPE_CHECKING:
+    import cirq
+
 
 class Gauge(abc.ABC):
     """A gauge replaces a two qubit gate with an equivalent subcircuit.
@@ -49,7 +53,7 @@ class Gauge(abc.ABC):
         return 1.0
 
     @abc.abstractmethod
-    def sample(self, gate: ops.Gate, prng: np.random.Generator) -> "ConstantGauge":
+    def sample(self, gate: ops.Gate, prng: np.random.Generator) -> ConstantGauge:
         """Returns a ConstantGauge sampled from a family of gauges.
 
         Args:
@@ -66,30 +70,30 @@ class ConstantGauge(Gauge):
     """A gauge that replaces a two qubit gate with a constant gauge."""
 
     two_qubit_gate: ops.Gate
-    pre_q0: Tuple[ops.Gate, ...] = field(
+    pre_q0: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
-    pre_q1: Tuple[ops.Gate, ...] = field(
+    pre_q1: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
-    post_q0: Tuple[ops.Gate, ...] = field(
+    post_q0: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
-    post_q1: Tuple[ops.Gate, ...] = field(
+    post_q1: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
     swap_qubits: bool = False
 
-    def sample(self, gate: ops.Gate, prng: np.random.Generator) -> "ConstantGauge":
+    def sample(self, gate: ops.Gate, prng: np.random.Generator) -> ConstantGauge:
         return self
 
     @property
-    def pre(self) -> Tuple[Tuple[ops.Gate, ...], Tuple[ops.Gate, ...]]:
+    def pre(self) -> tuple[tuple[ops.Gate, ...], tuple[ops.Gate, ...]]:
         """A tuple (ops to apply to q0, ops to apply to q1)."""
         return self.pre_q0, self.pre_q1
 
     @property
-    def post(self) -> Tuple[Tuple[ops.Gate, ...], Tuple[ops.Gate, ...]]:
+    def post(self) -> tuple[tuple[ops.Gate, ...], tuple[ops.Gate, ...]]:
         """A tuple (ops to apply to q0, ops to apply to q1)."""
         return self.post_q0, self.post_q1
 
@@ -104,16 +108,16 @@ class ConstantGauge(Gauge):
 class SameGateGauge(Gauge):
     """Same as ConstantGauge but the new two-qubit gate equals the old gate."""
 
-    pre_q0: Tuple[ops.Gate, ...] = field(
+    pre_q0: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
-    pre_q1: Tuple[ops.Gate, ...] = field(
+    pre_q1: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
-    post_q0: Tuple[ops.Gate, ...] = field(
+    post_q0: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
-    post_q1: Tuple[ops.Gate, ...] = field(
+    post_q1: tuple[ops.Gate, ...] = field(
         default=(), converter=lambda g: (g,) if isinstance(g, ops.Gate) else tuple(g)
     )
     swap_qubits: bool = False
@@ -140,12 +144,12 @@ class TwoQubitGateSymbolizer:
         n_symbols: The number of symbols to use for parameterization.
     """
 
-    symbolizer_fn: Callable[[ops.Gate, Sequence[sympy.Symbol]], Tuple[ops.Gate, Dict[str, Real]]]
+    symbolizer_fn: Callable[[ops.Gate, Sequence[sympy.Symbol]], tuple[ops.Gate, dict[str, Real]]]
     n_symbols: int
 
     def __call__(
         self, two_qubit_gate: ops.Gate, symbols: Sequence[sympy.Symbol]
-    ) -> Tuple[ops.Gate, Dict[str, Real]]:
+    ) -> tuple[ops.Gate, dict[str, Real]]:
         """Symbolizes a two qubit gate to a parameterized gate.
 
         Args:
@@ -193,9 +197,9 @@ class GaugeTransformer:
         self,
         # target can be either a specific gate, gatefamily or gateset
         # which allows matching parametric gates.
-        target: Union[ops.Gate, ops.Gateset, ops.GateFamily],
+        target: ops.Gate | ops.Gateset | ops.GateFamily,
         gauge_selector: Callable[[np.random.Generator], Gauge],
-        two_qubit_gate_symbolizer: Optional[TwoQubitGateSymbolizer] = None,
+        two_qubit_gate_symbolizer: TwoQubitGateSymbolizer | None = None,
     ) -> None:
         """Constructs a GaugeTransformer.
 
@@ -213,8 +217,8 @@ class GaugeTransformer:
         self,
         circuit: circuits.AbstractCircuit,
         *,
-        context: Optional[transformer_api.TransformerContext] = None,
-        prng: Optional[np.random.Generator] = None,
+        context: transformer_api.TransformerContext | None = None,
+        prng: np.random.Generator | None = None,
     ) -> circuits.AbstractCircuit:
         rng = np.random.default_rng() if prng is None else prng
         if context is None:
@@ -222,12 +226,12 @@ class GaugeTransformer:
         if context.deep:
             raise ValueError('GaugeTransformer cannot be used with deep=True')
         new_moments = []
-        left: List[List[ops.Operation]] = []
-        right: List[List[ops.Operation]] = []
+        left: list[list[ops.Operation]] = []
+        right: list[list[ops.Operation]] = []
         for moment in circuit:
             left.clear()
             right.clear()
-            center: List[ops.Operation] = []
+            center: list[ops.Operation] = []
             for op in moment:
                 if isinstance(op, ops.TaggedOperation) and set(op.tags).intersection(
                     context.tags_to_ignore
@@ -254,9 +258,9 @@ class GaugeTransformer:
         circuit: circuits.AbstractCircuit,
         *,
         N: int,
-        context: Optional[transformer_api.TransformerContext] = None,
-        prng: Optional[np.random.Generator] = None,
-    ) -> Tuple[circuits.AbstractCircuit, sweepable.Sweepable]:
+        context: transformer_api.TransformerContext | None = None,
+        prng: np.random.Generator | None = None,
+    ) -> tuple[circuits.AbstractCircuit, cirq.Sweepable]:
         """Generates a parameterized circuit with *N* sets of sweepable parameters.
 
         Args:
@@ -272,31 +276,31 @@ class GaugeTransformer:
             context = transformer_api.TransformerContext(deep=False)
         if context.deep:
             raise ValueError('GaugeTransformer cannot be used with deep=True')
-        new_moments: List[List[ops.Operation]] = []  # Store parameterized circuits.
+        new_moments: list[list[ops.Operation]] = []  # Store parameterized circuits.
         phxz_sid = itertools.count()
         two_qubit_gate_sid = itertools.count()
         # Map from "((pre|post),$qid,$moment_id)" to gate parameters.
         # E.g., {(post,q1,2): {"x_exponent": "x1", "z_exponent": "z1", "axis_phase": "a1"}}
-        phxz_symbols_by_locs: Dict[Tuple[str, ops.Qid, int], Dict[str, sympy.Symbol]] = {}
+        phxz_symbols_by_locs: dict[tuple[str, ops.Qid, int], dict[str, sympy.Symbol]] = {}
         # Map from "($q0,$q1,$moment_id)" to gate parameters.
         # E.g., {(q0,q1,0): ["s0"]}.
-        two_qubit_gate_symbols_by_locs: Dict[Tuple[ops.Qid, ops.Qid, int], List[sympy.Symbol]] = {}
+        two_qubit_gate_symbols_by_locs: dict[tuple[ops.Qid, ops.Qid, int], list[sympy.Symbol]] = {}
 
-        def single_qubit_next_symbol() -> Dict[str, sympy.Symbol]:
+        def single_qubit_next_symbol() -> dict[str, sympy.Symbol]:
             sid = next(phxz_sid)
             return _parameterize_to_phxz(sid)
 
-        def two_qubit_gate_next_symbol_list(n: int) -> List[sympy.Symbol]:
+        def two_qubit_gate_next_symbol_list(n: int) -> list[sympy.Symbol]:
             """Returns symbols for 2 qubit gate parameterization."""
             sid = next(two_qubit_gate_sid)
-            symbols: List[sympy.Symbol] = [sympy.Symbol(f"s{sid}_{sub}") for sub in range(n)]
+            symbols: list[sympy.Symbol] = [sympy.Symbol(f"s{sid}_{sub}") for sub in range(n)]
             return symbols
 
         # Build parameterized circuit.
         for moment_id, moment in enumerate(circuit):
-            center_moment: List[ops.Operation] = []
-            left_moment: List[ops.Operation] = []
-            right_moment: List[ops.Operation] = []
+            center_moment: list[ops.Operation] = []
+            left_moment: list[ops.Operation] = []
+            right_moment: list[ops.Operation] = []
             for op in moment:
                 if isinstance(op, ops.TaggedOperation) and set(op.tags).intersection(
                     context.tags_to_ignore
@@ -338,7 +342,7 @@ class GaugeTransformer:
             )
 
         # Initialize the map from symbol names to their N values.
-        values_by_params: Dict[str, List[float]] = {
+        values_by_params: dict[str, list[float]] = {
             **{
                 str(symbol): []
                 for symbols_by_names in phxz_symbols_by_locs.values()
@@ -385,14 +389,14 @@ class GaugeTransformer:
                             for key, value in phxz_params.items():
                                 values_by_params[key].append(float(value))
 
-        sweeps: List[Points] = [
+        sweeps: list[Points] = [
             Points(key=key, points=values) for key, values in values_by_params.items()
         ]
 
         return circuits.Circuit.from_moments(*new_moments), Zip(*sweeps)
 
 
-def _build_moments(operation_by_qubits: List[List[ops.Operation]]) -> List[List[ops.Operation]]:
+def _build_moments(operation_by_qubits: list[list[ops.Operation]]) -> list[list[ops.Operation]]:
     """Builds moments from a list of operations grouped by qubits.
 
     Returns a list of moments from a list whose ith element is a list of operations applied
@@ -404,7 +408,7 @@ def _build_moments(operation_by_qubits: List[List[ops.Operation]]) -> List[List[
     return moments
 
 
-def _parameterize_to_phxz(symbol_id: int) -> Dict[str, sympy.Symbol]:
+def _parameterize_to_phxz(symbol_id: int) -> dict[str, sympy.Symbol]:
     """Returns symbolized parameters for the gate."""
 
     # Parameterize single qubit gate to parameterized PhasedXZGate.
@@ -417,8 +421,8 @@ def _parameterize_to_phxz(symbol_id: int) -> Dict[str, sympy.Symbol]:
 
 
 def _gate_sequence_to_phxz_params(
-    gates: Tuple[ops.Gate, ...], xza_by_symbols: Dict[str, sympy.Symbol]
-) -> Dict[str, float]:
+    gates: tuple[ops.Gate, ...], xza_by_symbols: dict[str, sympy.Symbol]
+) -> dict[str, float]:
     identity_gate_in_phxz = {
         str(xza_by_symbols["x_exponent"]): 0.0,
         str(xza_by_symbols["z_exponent"]): 0.0,

cirq/transformers/gauge_compiling/gauge_compiling_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 unittest.mock
 
 import numpy as np

cirq/transformers/gauge_compiling/gauge_compiling_test_utils.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 from unittest.mock import patch
 

cirq/transformers/gauge_compiling/gauge_compiling_test_utils_test.py

@@ -12,13 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
-import numpy as np
+from typing import TYPE_CHECKING
 
 import cirq
 from cirq.transformers import ConstantGauge, GaugeSelector, GaugeTransformer
 from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester
 
+if TYPE_CHECKING:
+    import numpy as np
+
 
 class ExampleGate(cirq.testing.TwoQubitGate):
     unitary = cirq.unitary(cirq.CZ**0.123)

cirq/transformers/gauge_compiling/iswap_gauge.py

@@ -14,6 +14,8 @@
 
 """A Gauge transformer for ISWAP gate."""
 
+from __future__ import annotations
+
 import numpy as np
 
 from cirq import ops

cirq/transformers/gauge_compiling/iswap_gauge_test.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 import cirq
 from cirq.transformers.gauge_compiling import ISWAPGaugeTransformer

cirq/transformers/gauge_compiling/spin_inversion_gauge.py

@@ -14,6 +14,8 @@
 
 """The spin inversion gauge transformer."""
 
+from __future__ import annotations
+
 from cirq import ops
 from cirq.transformers.gauge_compiling.gauge_compiling import (
     GaugeSelector,

cirq/transformers/gauge_compiling/spin_inversion_gauge_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
 from cirq.transformers.gauge_compiling import SpinInversionGaugeTransformer
 from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester

cirq/transformers/gauge_compiling/sqrt_cz_gauge.py

@@ -14,12 +14,10 @@
 
 """A Gauge transformer for CZ**0.5 and CZ**-0.5 gates."""
 
+from __future__ import annotations
 
 from numbers import Real
-from typing import Dict, Sequence, Tuple, TYPE_CHECKING
-
-import numpy as np
-import sympy
+from typing import Sequence, TYPE_CHECKING
 
 from cirq.ops import CZ, CZPowGate, Gate, Gateset, S, X
 from cirq.transformers.gauge_compiling.gauge_compiling import (
@@ -31,6 +29,9 @@ from cirq.transformers.gauge_compiling.gauge_compiling import (
 )
 
 if TYPE_CHECKING:
+    import numpy as np
+    import sympy
+
     import cirq
 
 _SQRT_CZ = CZ**0.5
@@ -42,7 +43,7 @@ class SqrtCZGauge(Gauge):
     def weight(self) -> float:
         return 3.0
 
-    def sample(self, gate: 'cirq.Gate', prng: np.random.Generator) -> ConstantGauge:
+    def sample(self, gate: cirq.Gate, prng: np.random.Generator) -> ConstantGauge:
         if prng.choice([True, False]):
             return ConstantGauge(two_qubit_gate=gate)
         swap_qubits = prng.choice([True, False])
@@ -65,7 +66,7 @@ class SqrtCZGauge(Gauge):
 
 def _symbolize_as_cz_pow(
     two_qubit_gate: Gate, symbols: Sequence[sympy.Symbol]
-) -> Tuple[Gate, Dict[str, Real]]:
+) -> tuple[Gate, dict[str, Real]]:
     """Symbolizes a CZPowGate to a parameterized CZPowGate."""
 
     if not isinstance(two_qubit_gate, CZPowGate) or not isinstance(two_qubit_gate.exponent, Real):

cirq/transformers/gauge_compiling/sqrt_cz_gauge_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
 from cirq.transformers.gauge_compiling import SqrtCZGaugeTransformer
 from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester

cirq/transformers/gauge_compiling/sqrt_iswap_gauge.py

@@ -14,6 +14,8 @@
 
 """A Gauge transformer for SQRT_ISWAP gate."""
 
+from __future__ import annotations
+
 import numpy as np
 
 from cirq import ops

cirq/transformers/gauge_compiling/sqrt_iswap_gauge_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
 from cirq.transformers.gauge_compiling import SqrtISWAPGaugeTransformer
 from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester

cirq/transformers/heuristic_decompositions/gate_tabulation_math_utils.py

@@ -1,12 +1,15 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import itertools
-from typing import Optional, Sequence, Union
+from typing import Sequence
 
 import numpy as np
 
 from cirq.value import random_state
 
-_RealArraylike = Union[np.ndarray, float]
+_RealArraylike = np.ndarray | float
 
 
 def _single_qubit_unitary(
@@ -45,7 +48,7 @@ def _single_qubit_unitary(
 def random_qubit_unitary(
     shape: Sequence[int] = (),
     randomize_global_phase: bool = False,
-    rng: Optional[np.random.RandomState] = None,
+    rng: np.random.RandomState | None = None,
 ) -> np.ndarray:
     """Random qubit unitary distributed over the Haar measure.
 

cirq/transformers/heuristic_decompositions/gate_tabulation_math_utils_test.py

@@ -1,4 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import numpy as np
 import pytest
 

cirq/transformers/heuristic_decompositions/two_qubit_gate_tabulation.py

@@ -14,9 +14,12 @@
 
 """Attempt to tabulate single qubit gates required to generate a target 2Q gate
 with a product A k A."""
+
+from __future__ import annotations
+
 from dataclasses import dataclass
 from functools import reduce
-from typing import List, NamedTuple, Sequence, Tuple
+from typing import NamedTuple, Sequence
 
 import numpy as np
 
@@ -31,7 +34,7 @@ from cirq.transformers.heuristic_decompositions.gate_tabulation_math_utils impor
     weyl_chamber_mesh,
 )
 
-_SingleQubitGatePair = Tuple[np.ndarray, np.ndarray]
+_SingleQubitGatePair = tuple[np.ndarray, np.ndarray]
 
 
 class TwoQubitGateTabulationResult(NamedTuple):
@@ -58,7 +61,7 @@ class TwoQubitGateTabulationResult(NamedTuple):
 
     base_gate_unitary: np.ndarray
     target_gate: np.ndarray
-    local_unitaries: Tuple[_SingleQubitGatePair, ...]
+    local_unitaries: tuple[_SingleQubitGatePair, ...]
     actual_gate: np.ndarray
     success: bool
 
@@ -79,7 +82,7 @@ class TwoQubitGateTabulation:
     summary: str  # Text summarizing the results of the tabulation procedure.
     # Any KAK vectors which are expected to be compilable (within infidelity
     # max_expected_infidelity) using 2 or 3 base gates.
-    missed_points: Tuple[np.ndarray, ...]
+    missed_points: tuple[np.ndarray, ...]
 
     def compile_two_qubit_gate(self, unitary: np.ndarray) -> TwoQubitGateTabulationResult:
         r"""Compute single qubit gates required to compile a desired unitary.
@@ -198,7 +201,7 @@ class TwoQubitGateTabulation:
 
 def _outer_locals_for_unitary(
     target: np.ndarray, base: np.ndarray
-) -> Tuple[_SingleQubitGatePair, _SingleQubitGatePair, np.ndarray]:
+) -> tuple[_SingleQubitGatePair, _SingleQubitGatePair, np.ndarray]:
     """Local unitaries mapping between locally equivalent 2-local unitaries.
 
     Finds the left and right 1-local unitaries kL, kR such that
@@ -243,10 +246,10 @@ def _outer_locals_for_unitary(
 
 class _TabulationStepResult(NamedTuple):
     # Generated KAK vectors that are uniquely close to at least one mesh point.
-    kept_kaks: List[np.ndarray]
+    kept_kaks: list[np.ndarray]
     # The corresponding single qubit unitaries required to obtain the desired
     # KAK vectors.
-    kept_cycles: List[Tuple[_SingleQubitGatePair, ...]]
+    kept_cycles: list[tuple[_SingleQubitGatePair, ...]]
 
 
 def _tabulate_kak_vectors(
@@ -316,7 +319,7 @@ def two_qubit_gate_product_tabulation(
     *,
     sample_scaling: int = 50,
     allow_missed_points: bool = True,
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> TwoQubitGateTabulation:
     r"""Generate a TwoQubitGateTabulation for a base two qubit unitary.
 
@@ -358,7 +361,7 @@ def two_qubit_gate_product_tabulation(
 
     # include the base gate itself
     kak_vecs = [cirq.kak_vector(base_gate, check_preconditions=False)]
-    sq_cycles: List[Tuple[_SingleQubitGatePair, ...]] = [()]
+    sq_cycles: list[tuple[_SingleQubitGatePair, ...]] = [()]
 
     # Tabulate gates that are close to gates in the mesh
     u_locals_0 = random_qubit_unitary((num_samples,), rng=rng)

cirq/transformers/heuristic_decompositions/two_qubit_gate_tabulation_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 pytest
 
@@ -41,7 +43,7 @@ _random_2Q_unitaries = np.array([random_special_unitary(4, random_state=_rng) fo
 
 @pytest.mark.parametrize('tabulation', [sycamore_tabulation, sqrt_iswap_tabulation])
 @pytest.mark.parametrize('target', _random_2Q_unitaries)
-def test_gate_compilation_matches_expected_max_infidelity(tabulation, target):
+def test_gate_compilation_matches_expected_max_infidelity(tabulation, target) -> None:
     result = tabulation.compile_two_qubit_gate(target)
 
     assert result.success
@@ -50,7 +52,7 @@ def test_gate_compilation_matches_expected_max_infidelity(tabulation, target):
 
 
 @pytest.mark.parametrize('tabulation', [sycamore_tabulation, sqrt_iswap_tabulation])
-def test_gate_compilation_on_base_gate_standard(tabulation):
+def test_gate_compilation_on_base_gate_standard(tabulation) -> None:
     base_gate = tabulation.base_gate
 
     result = tabulation.compile_two_qubit_gate(base_gate)
@@ -61,7 +63,7 @@ def test_gate_compilation_on_base_gate_standard(tabulation):
     assert fidelity > 0.99999
 
 
-def test_gate_compilation_on_base_gate_identity():
+def test_gate_compilation_on_base_gate_identity() -> None:
     tabulation = two_qubit_gate_product_tabulation(np.eye(4), 0.25)
     base_gate = tabulation.base_gate
 
@@ -73,7 +75,7 @@ def test_gate_compilation_on_base_gate_identity():
     assert fidelity > 0.99999
 
 
-def test_gate_compilation_missing_points_raises_error():
+def test_gate_compilation_missing_points_raises_error() -> None:
     with pytest.raises(ValueError, match='Failed to tabulate a'):
         two_qubit_gate_product_tabulation(
             np.eye(4), 0.4, allow_missed_points=False, random_state=_rng
@@ -81,7 +83,7 @@ def test_gate_compilation_missing_points_raises_error():
 
 
 @pytest.mark.parametrize('seed', [0, 1])
-def test_sycamore_gate_tabulation(seed):
+def test_sycamore_gate_tabulation(seed) -> None:
     base_gate = cirq.unitary(cirq.FSimGate(np.pi / 2, np.pi / 6))
     tab = two_qubit_gate_product_tabulation(
         base_gate, 0.1, sample_scaling=2, random_state=np.random.RandomState(seed)
@@ -90,7 +92,7 @@ def test_sycamore_gate_tabulation(seed):
     assert result.success
 
 
-def test_sycamore_gate_tabulation_repr():
+def test_sycamore_gate_tabulation_repr() -> None:
     simple_tabulation = TwoQubitGateTabulation(
         np.array([[(1 + 0j), 0j, 0j, 0j]], dtype=np.complex128),
         np.array([[(1 + 0j), 0j, 0j, 0j]], dtype=np.complex128),
@@ -102,7 +104,7 @@ def test_sycamore_gate_tabulation_repr():
     assert_equivalent_repr(simple_tabulation)
 
 
-def test_sycamore_gate_tabulation_eq():
+def test_sycamore_gate_tabulation_eq() -> None:
     assert sycamore_tabulation == sycamore_tabulation
     assert sycamore_tabulation != sqrt_iswap_tabulation
     assert sycamore_tabulation != 1

cirq/transformers/insertion_sort.py

@@ -14,7 +14,9 @@
 
 """Transformer that sorts commuting operations in increasing order of their `.qubits` tuple."""
 
-from typing import Dict, List, Optional, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 from cirq import circuits, protocols
 from cirq.transformers import transformer_api
@@ -25,8 +27,8 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer(add_deep_support=True)
 def insertion_sort_transformer(
-    circuit: 'cirq.AbstractCircuit', *, context: Optional['cirq.TransformerContext'] = None
-) -> 'cirq.Circuit':
+    circuit: cirq.AbstractCircuit, *, context: cirq.TransformerContext | None = None
+) -> cirq.Circuit:
     """Sorts the operations using their sorted `.qubits` property as comparison key.
 
     Operations are swapped only if they commute.
@@ -35,11 +37,11 @@ def insertion_sort_transformer(
         circuit: input circuit.
         context: optional TransformerContext (not used),
     """
-    final_operations: List['cirq.Operation'] = []
-    qubit_index: Dict['cirq.Qid', int] = {
+    final_operations: list[cirq.Operation] = []
+    qubit_index: dict[cirq.Qid, int] = {
         q: idx for idx, q in enumerate(sorted(circuit.all_qubits()))
     }
-    cached_qubit_indices: Dict[int, List[int]] = {}
+    cached_qubit_indices: dict[int, list[int]] = {}
     for pos, op in enumerate(circuit.all_operations()):
         # here `pos` is at the append position of final_operations
         if (op_qubit_indices := cached_qubit_indices.get(id(op))) is None:

cirq/transformers/insertion_sort_test.py

@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 import cirq.transformers
 
 
-def test_insertion_sort():
+def test_insertion_sort() -> None:
     c = cirq.Circuit(
         cirq.CZ(cirq.q(2), cirq.q(1)),
         cirq.CZ(cirq.q(2), cirq.q(4)),