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

cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import List, Sequence, Tuple
+from typing import Sequence
 
 import numpy as np
 import pytest
@@ -113,9 +113,9 @@ def test_valid_cphase_exponents(theta, phi):
                 assert_decomposition_valid(cphase_gate, fsim_gate=fsim_gate)
 
 
-def complement_intervals(intervals: Sequence[Tuple[float, float]]) -> Sequence[Tuple[float, float]]:
+def complement_intervals(intervals: Sequence[tuple[float, float]]) -> Sequence[tuple[float, float]]:
     """Computes complement of union of intervals in [0, 2]."""
-    complements: List[Tuple[float, float]] = []
+    complements: list[tuple[float, float]] = []
     a = 0.0
     for b, c in intervals:
         complements.append((a, b))

cirq/transformers/analytical_decompositions/pauli_string_decomposition.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import cast, Optional, Tuple
+from typing import cast
 
 import numpy as np
 import numpy.typing as npt
@@ -23,7 +23,7 @@ from cirq import protocols
 from cirq.ops import DensePauliString
 
 
-def _argmax(V: npt.NDArray) -> Tuple[int, float]:
+def _argmax(V: npt.NDArray) -> tuple[int, float]:
     """Returns a tuple (index of max number, max number)."""
     V = (V * V.conj()).real
     idx_max = np.argmax(V)
@@ -62,7 +62,7 @@ def _conjugate_with_hadamard(U: npt.NDArray) -> npt.NDArray:
     return U
 
 
-def unitary_to_pauli_string(U: npt.NDArray, eps: float = 1e-15) -> Optional[DensePauliString]:
+def unitary_to_pauli_string(U: npt.NDArray, eps: float = 1e-15) -> DensePauliString | None:
     """Attempts to find a pauli string (with possible phase) equivalent to U up to eps.
 
         Based on this answer https://shorturl.at/aA079.

cirq/transformers/analytical_decompositions/quantum_shannon_decomposition.py

@@ -21,7 +21,7 @@ https://arxiv.org/abs/quant-ph/0406176
 
 from __future__ import annotations
 
-from typing import Callable, Iterable, List, TYPE_CHECKING
+from typing import Callable, Iterable, TYPE_CHECKING
 
 import numpy as np
 from scipy.linalg import cossin
@@ -42,7 +42,7 @@ if TYPE_CHECKING:
 
 
 def quantum_shannon_decomposition(
-    qubits: List[cirq.Qid], u: np.ndarray, atol: float = 1e-8
+    qubits: list[cirq.Qid], u: np.ndarray, atol: float = 1e-8
 ) -> Iterable[cirq.Operation]:
     """Decomposes n-qubit unitary 1-q, 2-q and GlobalPhase gates, preserving global phase.
 
@@ -185,7 +185,7 @@ def _single_qubit_decomposition(qubit: cirq.Qid, u: np.ndarray) -> Iterable[cirq
 
 
 def _msb_demuxer(
-    demux_qubits: List[cirq.Qid], u1: np.ndarray, u2: np.ndarray
+    demux_qubits: list[cirq.Qid], u1: np.ndarray, u2: np.ndarray
 ) -> Iterable[cirq.Operation]:
     """Demultiplexes a unitary matrix that is multiplexed in its most-significant-qubit.
 
@@ -248,7 +248,7 @@ def _nth_gray(n: int) -> int:
 
 
 def _multiplexed_cossin(
-    cossin_qubits: List[cirq.Qid], angles: List[float], rot_func: Callable = ops.ry
+    cossin_qubits: list[cirq.Qid], angles: list[float], rot_func: Callable = ops.ry
 ) -> Iterable[cirq.Operation]:
     """Performs a multiplexed rotation over all qubits in this unitary matrix,
 

cirq/transformers/analytical_decompositions/single_qubit_decompositions.py

@@ -17,7 +17,6 @@
 from __future__ import annotations
 
 import math
-from typing import List, Optional, Tuple
 
 import numpy as np
 import sympy
@@ -41,7 +40,7 @@ def _signed_mod_1(x: float) -> float:
 
 def single_qubit_matrix_to_pauli_rotations(
     mat: np.ndarray, atol: float = 0
-) -> List[Tuple[ops.Pauli, float]]:
+) -> list[tuple[ops.Pauli, float]]:
     """Implements a single-qubit operation with few rotations.
 
     Args:
@@ -100,7 +99,7 @@ def single_qubit_matrix_to_pauli_rotations(
     return [(pauli, ht) for pauli, ht in rotation_list if not is_no_turn(ht)]
 
 
-def single_qubit_matrix_to_gates(mat: np.ndarray, tolerance: float = 0) -> List[ops.Gate]:
+def single_qubit_matrix_to_gates(mat: np.ndarray, tolerance: float = 0) -> list[ops.Gate]:
     """Implements a single-qubit operation with few gates.
 
     Args:
@@ -116,7 +115,7 @@ def single_qubit_matrix_to_gates(mat: np.ndarray, tolerance: float = 0) -> List[
     return [pauli**ht for pauli, ht in rotations]
 
 
-def single_qubit_op_to_framed_phase_form(mat: np.ndarray) -> Tuple[np.ndarray, complex, complex]:
+def single_qubit_op_to_framed_phase_form(mat: np.ndarray) -> tuple[np.ndarray, complex, complex]:
     """Decomposes a 2x2 unitary M into U^-1 * diag(1, r) * U * diag(g, g).
 
     U translates the rotation axis of M to the Z axis.
@@ -143,7 +142,7 @@ def single_qubit_op_to_framed_phase_form(mat: np.ndarray) -> Tuple[np.ndarray, c
     return u, r, g
 
 
-def _deconstruct_single_qubit_matrix_into_gate_turns(mat: np.ndarray) -> Tuple[float, float, float]:
+def _deconstruct_single_qubit_matrix_into_gate_turns(mat: np.ndarray) -> tuple[float, float, float]:
     """Breaks down a 2x2 unitary into gate parameters.
 
     Args:
@@ -167,7 +166,7 @@ def _deconstruct_single_qubit_matrix_into_gate_turns(mat: np.ndarray) -> Tuple[f
     return (_signed_mod_1(xy_turn), _signed_mod_1(xy_phase_turn), _signed_mod_1(total_z_turn))
 
 
-def single_qubit_matrix_to_phased_x_z(mat: np.ndarray, atol: float = 0) -> List[ops.Gate]:
+def single_qubit_matrix_to_phased_x_z(mat: np.ndarray, atol: float = 0) -> list[ops.Gate]:
     """Implements a single-qubit operation with a PhasedX and Z gate.
 
     If one of the gates isn't needed, it will be omitted.
@@ -198,7 +197,7 @@ def single_qubit_matrix_to_phased_x_z(mat: np.ndarray, atol: float = 0) -> List[
     return result
 
 
-def single_qubit_matrix_to_phxz(mat: np.ndarray, atol: float = 0) -> Optional[ops.PhasedXZGate]:
+def single_qubit_matrix_to_phxz(mat: np.ndarray, atol: float = 0) -> ops.PhasedXZGate | None:
     """Implements a single-qubit operation with a PhasedXZ gate.
 
     Under the hood, this uses deconstruct_single_qubit_matrix_into_angles which

cirq/transformers/analytical_decompositions/single_to_two_qubit_isometry.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import List, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -34,7 +34,7 @@ def two_qubit_matrix_to_cz_isometry(
     allow_partial_czs: bool = False,
     atol: float = 1e-8,
     clean_operations: bool = True,
-) -> List[cirq.Operation]:
+) -> list[cirq.Operation]:
     """Decomposes a 2q operation into at-most 2 CZs + 1q rotations; assuming `q0` is initially |0>.
 
     The method implements isometry from one to two qubits; assuming qubit `q0` is always in the |0>

cirq/transformers/analytical_decompositions/three_qubit_decomposition.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import List, Optional, Sequence, Tuple, Union
+from typing import Sequence
 
 import numpy as np
 
@@ -26,7 +26,7 @@ from cirq import ops, transformers as opt
 
 def three_qubit_matrix_to_operations(
     q0: ops.Qid, q1: ops.Qid, q2: ops.Qid, u: np.ndarray, atol: float = 1e-8
-) -> List[ops.Operation]:
+) -> list[ops.Operation]:
     """Returns operations for a 3 qubit unitary.
 
     The algorithm is described in Shende et al.:
@@ -87,7 +87,7 @@ def three_qubit_matrix_to_operations(
     return list(cirq.Circuit(vdh_ops + cs_ops + ud_ops).all_operations())
 
 
-def _cs_to_ops(q0: ops.Qid, q1: ops.Qid, q2: ops.Qid, theta: np.ndarray) -> List[ops.Operation]:
+def _cs_to_ops(q0: ops.Qid, q1: ops.Qid, q2: ops.Qid, theta: np.ndarray) -> list[ops.Operation]:
     """Converts theta angles based Cosine Sine matrix to operations.
 
     Using the optimization as per Appendix A.1, it uses CZ gates instead of
@@ -126,9 +126,9 @@ def _two_qubit_multiplexor_to_ops(
     u1: np.ndarray,
     u2: np.ndarray,
     shift_left: bool = True,
-    diagonal: Optional[np.ndarray] = None,
+    diagonal: np.ndarray | None = None,
     atol: float = 1e-8,
-) -> Tuple[Optional[np.ndarray], List[ops.Operation]]:
+) -> tuple[np.ndarray | None, list[ops.Operation]]:
     r"""Converts a two qubit double multiplexor to circuit.
     Input: U_1 ⊕ U_2, with select qubit a (i.e. a = |0> => U_1(b,c),
     a = |1> => U_2(b,c).
@@ -187,7 +187,7 @@ def _two_qubit_multiplexor_to_ops(
 
     w = d_v @ w
 
-    d_w: Optional[np.ndarray]
+    d_w: np.ndarray | None
 
     # if it's interesting to extract the diagonal then let's do it
     if shift_left:
@@ -260,7 +260,7 @@ def _middle_multiplexor_to_ops(q0: ops.Qid, q1: ops.Qid, q2: ops.Qid, eigvals: n
     return _optimize_multiplexed_angles_circuit(ops)
 
 
-def _multiplexed_angles(theta: Union[Sequence[float], np.ndarray]) -> np.ndarray:
+def _multiplexed_angles(theta: Sequence[float] | np.ndarray) -> np.ndarray:
     """Calculates the angles for a 4-way multiplexed rotation.
 
     For example, if we want rz(theta[i]) if the select qubits are in state

cirq/transformers/analytical_decompositions/two_qubit_state_preparation.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import List, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -41,7 +41,7 @@ def _1q_matrices_to_ops(g0, g1, q0, q1, include_identity=False):
 
 def prepare_two_qubit_state_using_sqrt_iswap(
     q0: cirq.Qid, q1: cirq.Qid, state: cirq.STATE_VECTOR_LIKE, *, use_sqrt_iswap_inv: bool = True
-) -> List[cirq.Operation]:
+) -> list[cirq.Operation]:
     """Prepares the given 2q state from |00> using at-most 1 √iSWAP gate + single qubit rotations.
 
     Entangled states are prepared using exactly 1 √iSWAP gate while product states are prepared
@@ -76,7 +76,7 @@ def prepare_two_qubit_state_using_sqrt_iswap(
 
 def prepare_two_qubit_state_using_cz(
     q0: cirq.Qid, q1: cirq.Qid, state: cirq.STATE_VECTOR_LIKE
-) -> List[cirq.Operation]:
+) -> list[cirq.Operation]:
     """Prepares the given 2q state from |00> using at-most 1 CZ gate + single qubit rotations.
 
     Entangled states are prepared using exactly 1 CZ gate while product states are prepared
@@ -109,7 +109,7 @@ def prepare_two_qubit_state_using_cz(
 
 def prepare_two_qubit_state_using_iswap(
     q0: cirq.Qid, q1: cirq.Qid, state: cirq.STATE_VECTOR_LIKE, use_iswap_inv: bool = False
-) -> List[cirq.Operation]:
+) -> list[cirq.Operation]:
     """Prepares the given 2q state from |00> using at-most 1 ISWAP gate + single qubit rotations.
 
     Entangled states are prepared using exactly 1 ISWAP gate while product states are prepared

cirq/transformers/analytical_decompositions/two_qubit_to_cz.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import cast, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import cast, Iterable, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -34,7 +34,7 @@ if TYPE_CHECKING:
 
 def _remove_partial_czs_or_fail(
     operations: Iterable[cirq.Operation], atol: float
-) -> List[cirq.Operation]:
+) -> list[cirq.Operation]:
     result = []
     for op in operations:
         if isinstance(op.gate, ops.CZPowGate):
@@ -57,7 +57,7 @@ def two_qubit_matrix_to_cz_operations(
     allow_partial_czs: bool,
     atol: float = 1e-8,
     clean_operations: bool = True,
-) -> List[ops.Operation]:
+) -> list[ops.Operation]:
     """Decomposes a two-qubit operation into Z/XY/CZ gates.
 
     Args:
@@ -93,7 +93,7 @@ def two_qubit_matrix_to_diagonal_and_cz_operations(
     allow_partial_czs: bool = False,
     atol: float = 1e-8,
     clean_operations: bool = True,
-) -> Tuple[np.ndarray, List[cirq.Operation]]:
+) -> tuple[np.ndarray, list[cirq.Operation]]:
     """Decomposes a 2-qubit unitary to a diagonal and the remaining operations.
 
     For a 2-qubit unitary V, return ops, a list of operations and
@@ -197,7 +197,7 @@ def _kak_decomposition_to_operations(
     kak: linalg.KakDecomposition,
     allow_partial_czs: bool,
     atol: float = 1e-8,
-) -> List[ops.Operation]:
+) -> list[ops.Operation]:
     """Assumes that the decomposition is canonical."""
     b0, b1 = kak.single_qubit_operations_before
     pre = [_do_single_on(b0, q0, atol=atol), _do_single_on(b1, q1, atol=atol)]
@@ -232,7 +232,7 @@ def _is_trivial_angle(rad: float, atol: float) -> bool:
 
 
 def _parity_interaction(
-    q0: cirq.Qid, q1: cirq.Qid, rads: float, atol: float, gate: Optional[ops.Gate] = None
+    q0: cirq.Qid, q1: cirq.Qid, rads: float, atol: float, gate: ops.Gate | None = None
 ):
     """Yields a ZZ interaction framed by the given operation."""
     if abs(rads) < atol:
@@ -263,7 +263,7 @@ def _do_single_on(u: np.ndarray, q: cirq.Qid, atol: float = 1e-8):
 def _non_local_part(
     q0: cirq.Qid,
     q1: cirq.Qid,
-    interaction_coefficients: Tuple[float, float, float],
+    interaction_coefficients: tuple[float, float, float],
     allow_partial_czs: bool,
     atol: float = 1e-8,
 ):

cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Iterable, Iterator, List, Optional, Sequence, TYPE_CHECKING, Union
+from typing import Iterable, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -27,10 +27,10 @@ if TYPE_CHECKING:
 
 
 def decompose_two_qubit_interaction_into_four_fsim_gates(
-    interaction: Union[cirq.SupportsUnitary, np.ndarray],
+    interaction: cirq.SupportsUnitary | np.ndarray,
     *,
-    fsim_gate: Union[cirq.FSimGate, cirq.ISwapPowGate],
-    qubits: Optional[Sequence[cirq.Qid]] = None,
+    fsim_gate: cirq.FSimGate | cirq.ISwapPowGate,
+    qubits: Sequence[cirq.Qid] | None = None,
 ) -> cirq.Circuit:
     """Decomposes operations into an FSimGate near theta=pi/2, phi=0.
 
@@ -100,7 +100,7 @@ def decompose_two_qubit_interaction_into_four_fsim_gates(
     return result
 
 
-def _sticky_0_to_1(v: float, *, atol: float) -> Optional[float]:
+def _sticky_0_to_1(v: float, *, atol: float) -> float | None:
     if 0 <= v <= 1:
         return v
     if 1 < v <= 1 + atol:
@@ -117,7 +117,7 @@ def _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
     canonical_x_kak_coefficient: float,
     canonical_y_kak_coefficient: float,
     atol: float = 1e-8,
-) -> List[cirq.Operation]:
+) -> list[cirq.Operation]:
     x = canonical_x_kak_coefficient
     y = canonical_y_kak_coefficient
     assert 0 <= y <= x <= np.pi / 4
@@ -176,10 +176,10 @@ _B = _BGate()
 
 
 def _decompose_two_qubit_interaction_into_two_b_gates(
-    interaction: Union[cirq.SupportsUnitary, np.ndarray, cirq.KakDecomposition],
+    interaction: cirq.SupportsUnitary | np.ndarray | cirq.KakDecomposition,
     *,
     qubits: Sequence[cirq.Qid],
-) -> List[cirq.Operation]:
+) -> list[cirq.Operation]:
     kak = linalg.kak_decomposition(interaction)
 
     result = _decompose_interaction_into_two_b_gates_ignoring_single_qubit_ops(
@@ -195,7 +195,7 @@ def _decompose_two_qubit_interaction_into_two_b_gates(
 
 def _decompose_b_gate_into_two_fsims(
     *, fsim_gate: cirq.FSimGate, qubits: Sequence[cirq.Qid]
-) -> List[cirq.Operation]:
+) -> list[cirq.Operation]:
     kak = linalg.kak_decomposition(_B)
 
     result = _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
@@ -214,7 +214,7 @@ def _decompose_b_gate_into_two_fsims(
 
 def _decompose_interaction_into_two_b_gates_ignoring_single_qubit_ops(
     qubits: Sequence[cirq.Qid], kak_interaction_coefficients: Iterable[float]
-) -> List[cirq.Operation]:
+) -> list[cirq.Operation]:
     """Decompose using a minimal construction of two-qubit operations.
 
     References:
@@ -238,7 +238,7 @@ def _decompose_interaction_into_two_b_gates_ignoring_single_qubit_ops(
 
 
 def _fix_single_qubit_gates_around_kak_interaction(
-    *, desired: cirq.KakDecomposition, operations: List[cirq.Operation], qubits: Sequence[cirq.Qid]
+    *, desired: cirq.KakDecomposition, operations: list[cirq.Operation], qubits: Sequence[cirq.Qid]
 ) -> Iterator[cirq.Operation]:
     """Adds single qubit operations to complete a desired interaction.
 

cirq/transformers/analytical_decompositions/two_qubit_to_ms.py

@@ -21,7 +21,7 @@ Gate compilation methods implemented here are following the paper below:
 
 from __future__ import annotations
 
-from typing import cast, Iterable, List, Optional, Tuple, TYPE_CHECKING
+from typing import cast, Iterable, TYPE_CHECKING
 
 from cirq import linalg, ops, protocols
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions, two_qubit_to_cz
@@ -34,7 +34,7 @@ if TYPE_CHECKING:
 
 def two_qubit_matrix_to_ion_operations(
     q0: cirq.Qid, q1: cirq.Qid, mat: np.ndarray, atol: float = 1e-8, clean_operations: bool = True
-) -> List[ops.Operation]:
+) -> list[ops.Operation]:
     """Decomposes a two-qubit operation into MS/single-qubit rotation gates.
 
     Args:
@@ -55,7 +55,7 @@ def two_qubit_matrix_to_ion_operations(
 
 def _kak_decomposition_to_operations(
     q0: cirq.Qid, q1: cirq.Qid, kak: linalg.KakDecomposition, atol: float = 1e-8
-) -> List[ops.Operation]:
+) -> list[ops.Operation]:
     """Assumes that the decomposition is canonical."""
     b0, b1 = kak.single_qubit_operations_before
     pre = [_do_single_on(b0, q0, atol), _do_single_on(b1, q1, atol)]
@@ -78,7 +78,7 @@ def _do_single_on(u: np.ndarray, q: cirq.Qid, atol: float = 1e-8):
 
 
 def _parity_interaction(
-    q0: cirq.Qid, q1: cirq.Qid, rads: float, atol: float, gate: Optional[ops.Gate] = None
+    q0: cirq.Qid, q1: cirq.Qid, rads: float, atol: float, gate: ops.Gate | None = None
 ):
     """Yields an XX interaction framed by the given operation."""
 
@@ -98,7 +98,7 @@ def _parity_interaction(
 def _non_local_part(
     q0: cirq.Qid,
     q1: cirq.Qid,
-    interaction_coefficients: Tuple[float, float, float],
+    interaction_coefficients: tuple[float, float, float],
     atol: float = 1e-8,
 ):
     """Yields non-local operation of KAK decomposition."""

cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap.py

@@ -22,7 +22,7 @@ References:
 
 from __future__ import annotations
 
-from typing import Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -233,7 +233,7 @@ def two_qubit_matrix_to_sqrt_iswap_operations(
     q1: cirq.Qid,
     mat: np.ndarray,
     *,
-    required_sqrt_iswap_count: Optional[int] = None,
+    required_sqrt_iswap_count: int | None = None,
     use_sqrt_iswap_inv: bool = False,
     atol: float = 1e-8,
     check_preconditions: bool = True,
@@ -303,7 +303,7 @@ def _kak_decomposition_to_sqrt_iswap_operations(
     q0: cirq.Qid,
     q1: cirq.Qid,
     kak: linalg.KakDecomposition,
-    required_sqrt_iswap_count: Optional[int] = None,
+    required_sqrt_iswap_count: int | None = None,
     use_sqrt_iswap_inv: bool = False,
     atol: float = 1e-8,
 ) -> Sequence[cirq.Operation]:
@@ -328,7 +328,7 @@ def _decomp_to_operations(
     q0: cirq.Qid,
     q1: cirq.Qid,
     two_qubit_gate: cirq.Gate,
-    single_qubit_operations: Sequence[Tuple[np.ndarray, np.ndarray]],
+    single_qubit_operations: Sequence[tuple[np.ndarray, np.ndarray]],
     u0_before: np.ndarray = np.eye(2),
     u0_after: np.ndarray = np.eye(2),
     atol: float = 1e-8,
@@ -401,8 +401,8 @@ def _decomp_to_operations(
 
 
 def _single_qubit_matrices_with_sqrt_iswap(
-    kak: cirq.KakDecomposition, required_sqrt_iswap_count: Optional[int] = None, atol: float = 1e-8
-) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
+    kak: cirq.KakDecomposition, required_sqrt_iswap_count: int | None = None, atol: float = 1e-8
+) -> tuple[Sequence[tuple[np.ndarray, np.ndarray]], complex]:
     """Computes the sequence of interleaved single-qubit unitary matrices in the
     sqrt-iSWAP decomposition."""
     decomposers = [
@@ -428,7 +428,7 @@ def _single_qubit_matrices_with_sqrt_iswap(
 
 
 def _in_0_region(
-    interaction_coefficients: Tuple[float, float, float], weyl_tol: float = 1e-8
+    interaction_coefficients: tuple[float, float, float], weyl_tol: float = 1e-8
 ) -> bool:
     """Tests if (x, y, z) ~= (0, 0, 0) assuming x, y, z are canonical."""
     x, y, z = interaction_coefficients
@@ -436,7 +436,7 @@ def _in_0_region(
 
 
 def _in_1sqrt_iswap_region(
-    interaction_coefficients: Tuple[float, float, float], weyl_tol: float = 1e-8
+    interaction_coefficients: tuple[float, float, float], weyl_tol: float = 1e-8
 ) -> bool:
     """Tests if (x, y, z) ~= (π/8, π/8, 0), assuming x, y, z are canonical."""
     x, y, z = interaction_coefficients
@@ -444,7 +444,7 @@ def _in_1sqrt_iswap_region(
 
 
 def _in_2sqrt_iswap_region(
-    interaction_coefficients: Tuple[float, float, float], weyl_tol: float = 1e-8
+    interaction_coefficients: tuple[float, float, float], weyl_tol: float = 1e-8
 ) -> bool:
     """Tests if (x, y, z) is inside or within weyl_tol of the volume
     x >= y + |z| assuming x, y, z are canonical.
@@ -461,7 +461,7 @@ def _in_2sqrt_iswap_region(
 
 
 def _in_3sqrt_iswap_region(
-    interaction_coefficients: Tuple[float, float, float], weyl_tol: float = 1e-8
+    interaction_coefficients: tuple[float, float, float], weyl_tol: float = 1e-8
 ) -> bool:
     """Any two-qubit operation is decomposable into three SQRT_ISWAP gates.
 
@@ -475,7 +475,7 @@ def _in_3sqrt_iswap_region(
 
 def _decomp_0_matrices(
     kak: cirq.KakDecomposition, atol: float = 1e-8
-) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
+) -> tuple[Sequence[tuple[np.ndarray, np.ndarray]], complex]:
     """Returns the single-qubit matrices for the 0-SQRT_ISWAP decomposition.
 
     Assumes canonical x, y, z and (x, y, z) = (0, 0, 0) within tolerance.
@@ -493,7 +493,7 @@ def _decomp_0_matrices(
 
 def _decomp_1sqrt_iswap_matrices(
     kak: cirq.KakDecomposition, atol: float = 1e-8
-) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
+) -> tuple[Sequence[tuple[np.ndarray, np.ndarray]], complex]:
     """Returns the single-qubit matrices for the 1-SQRT_ISWAP decomposition.
 
     Assumes canonical x, y, z and (x, y, z) = (π/8, π/8, 0) within tolerance.
@@ -506,7 +506,7 @@ def _decomp_1sqrt_iswap_matrices(
 
 def _decomp_2sqrt_iswap_matrices(
     kak: cirq.KakDecomposition, atol: float = 1e-8
-) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
+) -> tuple[Sequence[tuple[np.ndarray, np.ndarray]], complex]:
     """Returns the single-qubit matrices for the 2-SQRT_ISWAP decomposition.
 
     Assumes canonical x, y, z and x >= y + |z| within tolerance.  For x, y, z
@@ -569,7 +569,7 @@ def _decomp_2sqrt_iswap_matrices(
 
 def _decomp_3sqrt_iswap_matrices(
     kak: cirq.KakDecomposition, atol: float = 1e-8
-) -> Tuple[Sequence[Tuple[np.ndarray, np.ndarray]], complex]:
+) -> tuple[Sequence[tuple[np.ndarray, np.ndarray]], complex]:
     """Returns the single-qubit matrices for the 3-SQRT_ISWAP decomposition.
 
     Assumes any canonical x, y, z.  Three sqrt-iSWAP gates are only needed if

cirq/transformers/dynamical_decoupling.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 from functools import reduce
 from itertools import cycle
-from typing import Dict, Optional, Tuple, TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -33,7 +33,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _get_dd_sequence_from_schema_name(schema: str) -> Tuple[ops.Gate, ...]:
+def _get_dd_sequence_from_schema_name(schema: str) -> tuple[ops.Gate, ...]:
     """Gets dynamical decoupling sequence from a schema name."""
     match schema:
         case 'DEFAULT':
@@ -50,14 +50,14 @@ def _get_dd_sequence_from_schema_name(schema: str) -> Tuple[ops.Gate, ...]:
             raise ValueError('Invalid schema name.')
 
 
-def _pauli_up_to_global_phase(gate: ops.Gate) -> Union[ops.Pauli, None]:
+def _pauli_up_to_global_phase(gate: ops.Gate) -> ops.Pauli | None:
     for pauli_gate in [ops.X, ops.Y, ops.Z]:
         if protocols.equal_up_to_global_phase(gate, pauli_gate):
             return pauli_gate
     return None
 
 
-def _validate_dd_sequence(dd_sequence: Tuple[ops.Gate, ...]) -> None:
+def _validate_dd_sequence(dd_sequence: tuple[ops.Gate, ...]) -> None:
     """Validates a given dynamical decoupling sequence.
 
     The sequence should only consists of Pauli gates and is essentially an identity gate.
@@ -87,8 +87,8 @@ def _validate_dd_sequence(dd_sequence: Tuple[ops.Gate, ...]) -> None:
 
 
 def _parse_dd_sequence(
-    schema: Union[str, Tuple[ops.Gate, ...]],
-) -> Tuple[Tuple[ops.Gate, ...], Dict[ops.Gate, ops.Pauli]]:
+    schema: str | tuple[ops.Gate, ...],
+) -> tuple[tuple[ops.Gate, ...], dict[ops.Gate, ops.Pauli]]:
     """Parses and returns dynamical decoupling sequence and its associated pauli map from schema."""
     dd_sequence = None
     if isinstance(schema, str):
@@ -98,7 +98,7 @@ def _parse_dd_sequence(
         dd_sequence = schema
 
     # Map gate to Pauli gate. This is necessary as dd sequence might contain gates like X^-1.
-    pauli_map: Dict[ops.Gate, ops.Pauli] = {}
+    pauli_map: dict[ops.Gate, ops.Pauli] = {}
     for gate in dd_sequence:
         pauli_gate = _pauli_up_to_global_phase(gate)
         if pauli_gate is not None:
@@ -123,8 +123,8 @@ def _is_clifford_op(op: ops.Operation) -> bool:
 
 def _calc_busy_moment_range_of_each_qubit(
     circuit: circuits.FrozenCircuit,
-) -> Dict[ops.Qid, list[int]]:
-    busy_moment_range_by_qubit: Dict[ops.Qid, list[int]] = {
+) -> dict[ops.Qid, list[int]]:
+    busy_moment_range_by_qubit: dict[ops.Qid, list[int]] = {
         q: [len(circuit), -1] for q in circuit.all_qubits()
     }
     for moment_id, moment in enumerate(circuit):
@@ -139,7 +139,7 @@ def _is_insertable_moment(moment: circuits.Moment, single_qubit_gate_moments_onl
 
 
 def _merge_single_qubit_ops_to_phxz(
-    q: ops.Qid, operations: Tuple[ops.Operation, ...]
+    q: ops.Qid, operations: tuple[ops.Operation, ...]
 ) -> ops.Operation:
     """Merges [op1, op2, ...] and returns an equivalent op"""
     if len(operations) == 1:
@@ -152,7 +152,7 @@ def _merge_single_qubit_ops_to_phxz(
 
 def _try_merge_single_qubit_ops_of_two_moments(
     m1: circuits.Moment, m2: circuits.Moment
-) -> Tuple[circuits.Moment, ...]:
+) -> tuple[circuits.Moment, ...]:
     """Merge single qubit ops of 2 moments if possible, returns 2 moments otherwise."""
     for q in m1.qubits & m2.qubits:
         op1 = m1.operation_at(q)
@@ -208,8 +208,8 @@ def _need_merge_pulled_through(op_at_q: ops.Operation, is_at_last_busy_moment: b
 def add_dynamical_decoupling(
     circuit: cirq.AbstractCircuit,
     *,
-    context: Optional[cirq.TransformerContext] = None,
-    schema: Union[str, Tuple[ops.Gate, ...]] = 'DEFAULT',
+    context: cirq.TransformerContext | None = None,
+    schema: str | tuple[ops.Gate, ...] = 'DEFAULT',
     single_qubit_gate_moments_only: bool = True,
 ) -> cirq.Circuit:
     """Adds dynamical decoupling gate operations to a given circuit.