cirq-core 1.6.0.dev20250520054601__py3-none-any.whl → 1.6.0.dev20250520183459__py3-none-any.whl

cirq/testing/consistent_protocols.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Any, Dict, Optional, Sequence, Type
+from typing import Any, Sequence
 
 import numpy as np
 import sympy
@@ -49,11 +49,11 @@ def assert_implements_consistent_protocols(
     val: Any,
     *,
     exponents: Sequence[Any] = (0, 1, -1, 0.25, sympy.Symbol('s')),
-    qubit_count: Optional[int] = None,
+    qubit_count: int | None = None,
     ignoring_global_phase: bool = False,
     setup_code: str = 'import cirq\nimport numpy as np\nimport sympy',
-    global_vals: Optional[Dict[str, Any]] = None,
-    local_vals: Optional[Dict[str, Any]] = None,
+    global_vals: dict[str, Any] | None = None,
+    local_vals: dict[str, Any] | None = None,
     ignore_decompose_to_default_gateset: bool = False,
 ) -> None:
     """Checks that a value is internally consistent and has a good __repr__."""
@@ -83,15 +83,15 @@ def assert_implements_consistent_protocols(
 
 
 def assert_eigengate_implements_consistent_protocols(
-    eigen_gate_type: Type[ops.EigenGate],
+    eigen_gate_type: type[ops.EigenGate],
     *,
     exponents: Sequence[value.TParamVal] = (0, 1, -1, 0.25, sympy.Symbol('s')),
     global_shifts: Sequence[float] = (0, -0.5, 0.1),
-    qubit_count: Optional[int] = None,
+    qubit_count: int | None = None,
     ignoring_global_phase: bool = False,
     setup_code: str = 'import cirq\nimport numpy as np\nimport sympy',
-    global_vals: Optional[Dict[str, Any]] = None,
-    local_vals: Optional[Dict[str, Any]] = None,
+    global_vals: dict[str, Any] | None = None,
+    local_vals: dict[str, Any] | None = None,
     ignore_decompose_to_default_gateset: bool = False,
 ) -> None:
     """Checks that an EigenGate subclass is internally consistent and has a
@@ -145,8 +145,8 @@ def _assert_meets_standards_helper(
     *,
     ignoring_global_phase: bool,
     setup_code: str,
-    global_vals: Optional[Dict[str, Any]],
-    local_vals: Optional[Dict[str, Any]],
+    global_vals: dict[str, Any] | None,
+    local_vals: dict[str, Any] | None,
     ignore_decompose_to_default_gateset: bool,
 ) -> None:
     __tracebackhide__ = True  # pylint: disable=unused-variable

cirq/testing/consistent_protocols_test.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 from types import NotImplementedType
-from typing import AbstractSet, List, Sequence, Tuple, Union
+from typing import AbstractSet, Sequence
 
 import numpy as np
 import pytest
@@ -28,7 +28,7 @@ from cirq._compat import proper_repr
 
 class GoodGate(cirq.testing.SingleQubitGate):
     def __init__(
-        self, *, phase_exponent: Union[float, sympy.Expr], exponent: Union[float, sympy.Expr] = 1.0
+        self, *, phase_exponent: float | sympy.Expr, exponent: float | sympy.Expr = 1.0
     ) -> None:
         self.phase_exponent = cirq.canonicalize_half_turns(phase_exponent)
         self.exponent = exponent
@@ -36,14 +36,14 @@ class GoodGate(cirq.testing.SingleQubitGate):
     def _has_unitary_(self):
         return not cirq.is_parameterized(self)
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         if cirq.is_parameterized(self):
             return NotImplemented
         z = cirq.unitary(cirq.Z**self.phase_exponent)
         x = cirq.unitary(cirq.X**self.exponent)
         return np.dot(np.dot(z, x), np.conj(z))
 
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         if self.exponent != 1 or cirq.is_parameterized(self):
             return NotImplemented
 
@@ -85,7 +85,7 @@ class GoodGate(cirq.testing.SingleQubitGate):
             exponent=self.exponent, phase_exponent=self.phase_exponent + phase_turns * 2
         )
 
-    def __pow__(self, exponent: Union[float, sympy.Expr]) -> GoodGate:
+    def __pow__(self, exponent: float | sympy.Expr) -> GoodGate:
         new_exponent = cirq.mul(self.exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
             return NotImplemented  # pragma: no cover
@@ -129,7 +129,7 @@ class BadGateParameterNames(GoodGate):
 
 
 class BadGateApplyUnitaryToTensor(GoodGate):
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         if self.exponent != 1 or cirq.is_parameterized(self):
             return NotImplemented  # pragma: no cover
 
@@ -178,7 +178,7 @@ class BadGateRepr(GoodGate):
 
 
 class GoodEigenGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 0])), (1, np.diag([0, 1]))]
 
     def __repr__(self):

cirq/testing/consistent_qasm.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import warnings
-from typing import Any, List, Optional, Sequence
+from typing import Any, Sequence
 
 import numpy as np
 
@@ -87,8 +87,8 @@ qreg q[{num_qubits}];
             qasm_unitary, unitary, rtol=1e-8, atol=1e-8
         )
     except Exception as ex:
-        p_unitary: Optional[np.ndarray]
-        p_qasm_unitary: Optional[np.ndarray]
+        p_unitary: np.ndarray | None
+        p_qasm_unitary: np.ndarray | None
         if qasm_unitary is not None:
             p_unitary, p_qasm_unitary = linalg.match_global_phase(unitary, qasm_unitary)
         else:
@@ -127,7 +127,7 @@ def _indent(*content: str) -> str:
     return '    ' + '\n'.join(content).replace('\n', '\n    ')
 
 
-def _reorder_indices_of_matrix(matrix: np.ndarray, new_order: List[int]):
+def _reorder_indices_of_matrix(matrix: np.ndarray, new_order: list[int]):
     num_qubits = matrix.shape[0].bit_length() - 1
     matrix = np.reshape(matrix, (2,) * 2 * num_qubits)
     all_indices = range(2 * num_qubits)

cirq/testing/consistent_qasm_test.py

@@ -15,7 +15,6 @@
 from __future__ import annotations
 
 import warnings
-from typing import Tuple
 
 import numpy as np
 import pytest
@@ -43,13 +42,13 @@ class Fixed(cirq.Operation):
 
 
 class QuditGate(cirq.Gate):
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return (3, 3)
 
     def _unitary_(self):
         return np.eye(9)
 
-    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]):
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]):
         return NotImplemented
 
 

cirq/testing/devices.py

@@ -13,10 +13,9 @@
 # limitations under the License.
 
 """Provides test devices that can validate circuits."""
-
 from __future__ import annotations
 
-from typing import AbstractSet, cast, Tuple
+from typing import AbstractSet, cast
 
 from cirq import devices, ops
 
@@ -41,10 +40,10 @@ class ValidatingTestDevice(devices.Device):
         self,
         qubits: AbstractSet[ops.Qid],
         name: str = "ValidatingTestDevice",
-        allowed_gates: Tuple[type, ...] = (ops.Gate,),
-        allowed_qubit_types: Tuple[type, ...] = (devices.GridQubit,),
+        allowed_gates: tuple[type, ...] = (ops.Gate,),
+        allowed_qubit_types: tuple[type, ...] = (devices.GridQubit,),
         validate_locality: bool = False,
-        auto_decompose_gates: Tuple[type, ...] = tuple(),
+        auto_decompose_gates: tuple[type, ...] = tuple(),
     ):
         self.allowed_qubit_types = allowed_qubit_types
         self.allowed_gates = allowed_gates

cirq/testing/equals_tester.py

@@ -24,14 +24,14 @@ from __future__ import annotations
 
 import collections
 import itertools
-from typing import Any, Callable, List, Tuple, Union
+from typing import Any, Callable
 
 
 class EqualsTester:
     """Tests equality against user-provided disjoint equivalence groups."""
 
     def __init__(self) -> None:
-        self._groups: List[Tuple[Union[Any, _ClassUnknownToSubjects], ...]] = [
+        self._groups: list[tuple[Any | _ClassUnknownToSubjects, ...]] = [
             (_ClassUnknownToSubjects(),)
         ]
 

cirq/testing/equivalent_basis_map.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, Optional, Sequence
+from typing import Sequence
 
 import numpy as np
 
@@ -22,7 +22,7 @@ import cirq
 from cirq import circuits
 
 
-def assert_equivalent_computational_basis_map(maps: Dict[int, int], circuit: circuits.Circuit):
+def assert_equivalent_computational_basis_map(maps: dict[int, int], circuit: circuits.Circuit):
     """Ensure equivalence of basis state mapping.
 
     Args:
@@ -49,7 +49,7 @@ def assert_equivalent_computational_basis_map(maps: Dict[int, int], circuit: cir
 
 def _sparse_computational_basis_map(
     inputs: Sequence[int], circuit: circuits.Circuit
-) -> Dict[int, int]:
+) -> dict[int, int]:
     # Pick a unique amplitude for each computational basis input state.
     amps = [np.exp(1j * i / len(inputs)) / len(inputs) ** 0.5 for i in range(len(inputs))]
 
@@ -69,7 +69,7 @@ def _sparse_computational_basis_map(
     return actual_map
 
 
-def _bin_dec(x: Optional[int], num_bits: int) -> str:
+def _bin_dec(x: int | None, num_bits: int) -> str:
     if x is None:
         return 'None'
     return f'0b{bin(x)[2:].zfill(num_bits)} ({x})'

cirq/testing/equivalent_repr_eval.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Optional
+from typing import Any
 
 
 def assert_equivalent_repr(
@@ -23,8 +23,8 @@ def assert_equivalent_repr(
     setup_code: str = (
         'import cirq\nimport numpy as np\nimport sympy\nimport pandas as pd\nimport datetime\n'
     ),
-    global_vals: Optional[Dict[str, Any]] = None,
-    local_vals: Optional[Dict[str, Any]] = None,
+    global_vals: dict[str, Any] | None = None,
+    local_vals: dict[str, Any] | None = None,
 ) -> None:
     """Checks that eval(repr(v)) == v.
 

cirq/testing/json.py

@@ -20,7 +20,7 @@ import io
 import pathlib
 from dataclasses import dataclass
 from types import ModuleType
-from typing import Dict, Iterator, List, Set, Tuple, Type, TYPE_CHECKING
+from typing import Iterator, TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
@@ -48,28 +48,28 @@ class ModuleJsonTestSpec:
     # for test failures, a better representation
     name: str
     # the packages that have the public classes to be checked for serialization
-    packages: List[ModuleType]
+    packages: list[ModuleType]
     # the path for the folder containing the test files
     test_data_path: pathlib.Path
     # these public class names are planned to be serializable but not yet
-    not_yet_serializable: List[str]
+    not_yet_serializable: list[str]
     # these public class names do not need to be serialized ever
-    should_not_be_serialized: List[str]
+    should_not_be_serialized: list[str]
     # points to the resolver cache's dict for this module
-    resolver_cache: Dict[str, ObjectFactory]
+    resolver_cache: dict[str, ObjectFactory]
     # {DeprecatedClass: deprecation_deadline} pairs to avoid deprecation errors
     # in serialization tests.
-    deprecated: Dict[str, str]
+    deprecated: dict[str, str]
     # The unqualified public name is different from the cirq_type field of the json object,
     # usually due to namespacing.
-    custom_class_name_to_cirq_type: Dict[str, str] = dataclasses.field(default_factory=dict)
+    custom_class_name_to_cirq_type: dict[str, str] = dataclasses.field(default_factory=dict)
     # Special cases where classes cannot be tested using the normal infrastructure.
-    tested_elsewhere: List[str] = dataclasses.field(default_factory=list)
+    tested_elsewhere: list[str] = dataclasses.field(default_factory=list)
 
     def __repr__(self):
         return self.name
 
-    def _get_all_public_classes(self) -> Iterator[Tuple[str, Type]]:
+    def _get_all_public_classes(self) -> Iterator[tuple[str, type]]:
         for module in self.packages:
             for name, obj in inspect.getmembers(module):
                 if inspect.isfunction(obj) or inspect.ismodule(obj):
@@ -91,16 +91,16 @@ class ModuleJsonTestSpec:
                 name = self.custom_class_name_to_cirq_type.get(name, name)
                 yield name, obj
 
-    def find_classes_that_should_serialize(self) -> Set[Tuple[str, Type]]:
-        result: Set[Tuple[str, Type]] = set()
+    def find_classes_that_should_serialize(self) -> set[tuple[str, type]]:
+        result: set[tuple[str, type]] = set()
 
         result.update({(name, obj) for name, obj in self._get_all_public_classes()})
         result.update(self.get_resolver_cache_types())
 
         return result
 
-    def get_resolver_cache_types(self) -> Set[Tuple[str, Type]]:
-        result: Set[Tuple[str, Type]] = set()
+    def get_resolver_cache_types(self) -> set[tuple[str, type]]:
+        result: set[tuple[str, type]] = set()
         for k, v in self.resolver_cache.items():
             if isinstance(v, type):
                 result.add((k, v))
@@ -117,7 +117,7 @@ class ModuleJsonTestSpec:
         for name, _ in self.get_resolver_cache_types():
             yield name
 
-    def all_test_data_keys(self) -> List[str]:
+    def all_test_data_keys(self) -> list[str]:
         seen = set()
 
         for file in self.test_data_path.iterdir():

cirq/testing/logs.py

@@ -18,17 +18,17 @@ from __future__ import annotations
 
 import contextlib
 import logging
-from typing import Iterator, List, Optional
+from typing import Iterator
 
 
 @contextlib.contextmanager
 def assert_logs(
     *matches: str,
-    count: Optional[int] = 1,
+    count: int | None = 1,
     min_level: int = logging.WARNING,
     max_level: int = logging.CRITICAL,
     capture_warnings: bool = True,
-) -> Iterator[List[logging.LogRecord]]:
+) -> Iterator[list[logging.LogRecord]]:
     """A context manager for testing logging and warning events.
 
     To use this one wraps the code that is to be tested for log events within

cirq/testing/no_identifier_qubit.py

@@ -11,10 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
 from __future__ import annotations
 
-from typing import Any, Dict
+from typing import Any
 
 from cirq import protocols
 from cirq.ops import raw_types
@@ -38,5 +37,5 @@ class NoIdentifierQubit(raw_types.Qid):
     def __repr__(self) -> str:
         return 'cirq.testing.NoIdentifierQubit()'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, [])

cirq/testing/random_circuit.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Optional, Sequence, TYPE_CHECKING, Union
+from typing import Sequence, TYPE_CHECKING
 
 from cirq import circuits, ops, value
 from cirq._doc import document
@@ -22,7 +22,7 @@ from cirq._doc import document
 if TYPE_CHECKING:
     import cirq
 
-DEFAULT_GATE_DOMAIN: Dict[ops.Gate, int] = {
+DEFAULT_GATE_DOMAIN: dict[ops.Gate, int] = {
     ops.CNOT: 2,  # type: ignore[has-type]
     ops.CZ: 2,  # type: ignore[has-type]
     ops.H: 1,  # type: ignore[has-type]
@@ -46,10 +46,10 @@ and Z gates.
 
 
 def random_circuit(
-    qubits: Union[Sequence[cirq.Qid], int],
+    qubits: Sequence[cirq.Qid] | int,
     n_moments: int,
     op_density: float,
-    gate_domain: Optional[Dict[ops.Gate, int]] = None,
+    gate_domain: dict[ops.Gate, int] | None = None,
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> circuits.Circuit:
     """Generates a random circuit.
@@ -107,7 +107,7 @@ def random_circuit(
 
     prng = value.parse_random_state(random_state)
 
-    moments: List[circuits.Moment] = []
+    moments: list[circuits.Moment] = []
     gate_arity_pairs = sorted(gate_domain.items(), key=repr)
     num_gates = len(gate_domain)
     for _ in range(n_moments):
@@ -126,8 +126,8 @@ def random_circuit(
 
 def random_two_qubit_circuit_with_czs(
     num_czs: int = 3,
-    q0: Optional[cirq.Qid] = None,
-    q1: Optional[cirq.Qid] = None,
+    q0: cirq.Qid | None = None,
+    q1: cirq.Qid | None = None,
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> circuits.Circuit:
     """Creates a random two qubit circuit with the given number of CNOTs.

cirq/testing/random_circuit_test.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import random
-from typing import cast, Dict, Optional, Sequence, Union
+from typing import cast, Sequence
 
 import numpy as np
 import pytest
@@ -75,10 +75,10 @@ def _cases_for_random_circuit():
     'n_qubits,n_moments,op_density,gate_domain,pass_qubits', _cases_for_random_circuit()
 )
 def test_random_circuit(
-    n_qubits: Union[int, Sequence[cirq.Qid]],
+    n_qubits: int | Sequence[cirq.Qid],
     n_moments: int,
     op_density: float,
-    gate_domain: Optional[Dict[cirq.Gate, int]],
+    gate_domain: dict[cirq.Gate, int] | None,
     pass_qubits: bool,
 ) -> None:
     qubit_set = cirq.LineQubit.range(n_qubits)

cirq/transformers/analytical_decompositions/clifford_decomposition.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import functools
-from typing import List, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -30,8 +30,8 @@ if TYPE_CHECKING:
 def _X(
     q: int,
     args: sim.CliffordTableauSimulationState,
-    operations: List[ops.Operation],
-    qubits: List[cirq.Qid],
+    operations: list[ops.Operation],
+    qubits: list[cirq.Qid],
 ):
     protocols.act_on(ops.X, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.X(qubits[q]))
@@ -40,8 +40,8 @@ def _X(
 def _Z(
     q: int,
     args: sim.CliffordTableauSimulationState,
-    operations: List[ops.Operation],
-    qubits: List[cirq.Qid],
+    operations: list[ops.Operation],
+    qubits: list[cirq.Qid],
 ):
     protocols.act_on(ops.Z, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.Z(qubits[q]))
@@ -50,8 +50,8 @@ def _Z(
 def _Sdg(
     q: int,
     args: sim.CliffordTableauSimulationState,
-    operations: List[ops.Operation],
-    qubits: List[cirq.Qid],
+    operations: list[ops.Operation],
+    qubits: list[cirq.Qid],
 ):
     # Apply the tableau with S^\{dagger}
     protocols.act_on(ops.S**-1, args, qubits=[qubits[q]], allow_decompose=False)
@@ -61,8 +61,8 @@ def _Sdg(
 def _H(
     q: int,
     args: sim.CliffordTableauSimulationState,
-    operations: List[ops.Operation],
-    qubits: List[cirq.Qid],
+    operations: list[ops.Operation],
+    qubits: list[cirq.Qid],
 ):
     protocols.act_on(ops.H, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.H(qubits[q]))
@@ -72,8 +72,8 @@ def _CNOT(
     q1: int,
     q2: int,
     args: sim.CliffordTableauSimulationState,
-    operations: List[ops.Operation],
-    qubits: List[cirq.Qid],
+    operations: list[ops.Operation],
+    qubits: list[cirq.Qid],
 ):
     protocols.act_on(ops.CNOT, args, qubits=[qubits[q1], qubits[q2]], allow_decompose=False)
     operations.append(ops.CNOT(qubits[q1], qubits[q2]))
@@ -83,16 +83,16 @@ def _SWAP(
     q1: int,
     q2: int,
     args: sim.CliffordTableauSimulationState,
-    operations: List[ops.Operation],
-    qubits: List[cirq.Qid],
+    operations: list[ops.Operation],
+    qubits: list[cirq.Qid],
 ):
     protocols.act_on(ops.SWAP, args, qubits=[qubits[q1], qubits[q2]], allow_decompose=False)
     operations.append(ops.SWAP(qubits[q1], qubits[q2]))
 
 
 def decompose_clifford_tableau_to_operations(
-    qubits: List[cirq.Qid], clifford_tableau: qis.CliffordTableau
-) -> List[ops.Operation]:
+    qubits: list[cirq.Qid], clifford_tableau: qis.CliffordTableau
+) -> list[ops.Operation]:
     """Decompose an n-qubit Clifford Tableau into a list of one/two qubit operations.
 
     The implementation is based on Theorem 8 in [1].
@@ -116,7 +116,7 @@ def decompose_clifford_tableau_to_operations(
     ), "The provided clifford_tableau must satisfy the symplectic property."
 
     t: qis.CliffordTableau = clifford_tableau.copy()
-    operations: List[ops.Operation] = []
+    operations: list[ops.Operation] = []
     args = sim.CliffordTableauSimulationState(
         tableau=t, qubits=qubits, prng=np.random.RandomState()
     )

cirq/transformers/analytical_decompositions/controlled_gate_decomposition.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import List, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -40,7 +40,7 @@ def _flatten(x):
     return list(itertools.chain.from_iterable(x))
 
 
-def _decompose_abc(matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray, float]:
+def _decompose_abc(matrix: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray, float]:
     """Decomposes 2x2 unitary matrix.
 
     Returns 2x2 special unitary matrices A, B, C and phase delta, such that:
@@ -74,7 +74,7 @@ def _decompose_abc(matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarr
 
 def _decompose_single_ctrl(
     matrix: np.ndarray, control: cirq.Qid, target: cirq.Qid
-) -> List[cirq.Operation]:
+) -> list[cirq.Operation]:
     """Decomposes controlled gate with one control.
 
     See [1], chapter 5.1.
@@ -96,7 +96,7 @@ def _decompose_single_ctrl(
     return result
 
 
-def _ccnot_congruent(c0: cirq.Qid, c1: cirq.Qid, target: cirq.Qid) -> List[cirq.Operation]:
+def _ccnot_congruent(c0: cirq.Qid, c1: cirq.Qid, target: cirq.Qid) -> list[cirq.Operation]:
     """Implements 3-qubit gate 'congruent' to CCNOT.
 
     Returns sequence of operations which is equivalent to applying
@@ -114,8 +114,8 @@ def _ccnot_congruent(c0: cirq.Qid, c1: cirq.Qid, target: cirq.Qid) -> List[cirq.
 
 
 def decompose_multi_controlled_x(
-    controls: List[cirq.Qid], target: cirq.Qid, free_qubits: List[cirq.Qid]
-) -> List[cirq.Operation]:
+    controls: list[cirq.Qid], target: cirq.Qid, free_qubits: list[cirq.Qid]
+) -> list[cirq.Operation]:
     """Implements action of multi-controlled Pauli X gate.
 
     Result is guaranteed to consist exclusively of 1-qubit, CNOT and CCNOT
@@ -167,8 +167,8 @@ def decompose_multi_controlled_x(
 
 
 def _decompose_su(
-    matrix: np.ndarray, controls: List[cirq.Qid], target: cirq.Qid
-) -> List[cirq.Operation]:
+    matrix: np.ndarray, controls: list[cirq.Qid], target: cirq.Qid
+) -> list[cirq.Operation]:
     """Decomposes controlled special unitary gate into elementary gates.
 
     Result has O(len(controls)) operations.
@@ -193,10 +193,10 @@ def _decompose_su(
 def _decompose_recursive(
     matrix: np.ndarray,
     power: float,
-    controls: List[cirq.Qid],
+    controls: list[cirq.Qid],
     target: cirq.Qid,
-    free_qubits: List[cirq.Qid],
-) -> List[cirq.Operation]:
+    free_qubits: list[cirq.Qid],
+) -> list[cirq.Operation]:
     """Decomposes controlled unitary gate into elementary gates.
 
     Result has O(len(controls)^2) operations.
@@ -218,8 +218,8 @@ def _decompose_recursive(
 
 
 def decompose_multi_controlled_rotation(
-    matrix: np.ndarray, controls: List[cirq.Qid], target: cirq.Qid
-) -> List[cirq.Operation]:
+    matrix: np.ndarray, controls: list[cirq.Qid], target: cirq.Qid
+) -> list[cirq.Operation]:
     """Implements action of multi-controlled unitary gate.
 
     Returns a sequence of operations, which is equivalent to applying

cirq/transformers/analytical_decompositions/cphase_to_fsim.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -35,7 +35,7 @@ def _asinsin(x: float) -> float:
 
 def compute_cphase_exponents_for_fsim_decomposition(
     fsim_gate: cirq.FSimGate,
-) -> Sequence[Tuple[float, float]]:
+) -> Sequence[tuple[float, float]]:
     """Returns intervals of CZPowGate exponents valid for FSim decomposition.
 
     Ideal intervals associated with the constraints are closed, but due to
@@ -58,8 +58,8 @@ def compute_cphase_exponents_for_fsim_decomposition(
     """
 
     def nonempty_intervals(
-        intervals: Sequence[Tuple[float, float]],
-    ) -> Sequence[Tuple[float, float]]:
+        intervals: Sequence[tuple[float, float]],
+    ) -> Sequence[tuple[float, float]]:
         return tuple((a, b) for a, b in intervals if a < b)
 
     # Each of the two FSimGate parameters sets a bound on phase angle.
@@ -98,7 +98,7 @@ def decompose_cphase_into_two_fsim(
     cphase_gate: cirq.CZPowGate,
     *,
     fsim_gate: cirq.FSimGate,
-    qubits: Optional[Sequence[cirq.Qid]] = None,
+    qubits: Sequence[cirq.Qid] | None = None,
     atol: float = 1e-8,
 ) -> cirq.OP_TREE:
     """Decomposes CZPowGate into two FSimGates.