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

cirq/ops/classically_controlled_operation.py

@@ -14,19 +14,7 @@
 
 from __future__ import annotations
 
-from typing import (
-    AbstractSet,
-    Any,
-    Dict,
-    FrozenSet,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import AbstractSet, Any, Mapping, Sequence, TYPE_CHECKING
 
 import sympy
 
@@ -83,7 +71,7 @@ class ClassicallyControlledOperation(raw_types.Operation):
     def __init__(
         self,
         sub_operation: cirq.Operation,
-        conditions: Sequence[Union[str, cirq.MeasurementKey, cirq.Condition, sympy.Basic]],
+        conditions: Sequence[str | cirq.MeasurementKey | cirq.Condition | sympy.Basic],
     ):
         """Initializes a `ClassicallyControlledOperation`.
 
@@ -109,7 +97,7 @@ class ClassicallyControlledOperation(raw_types.Operation):
         if isinstance(sub_operation, ClassicallyControlledOperation):
             conditions += sub_operation._conditions
             sub_operation = sub_operation._sub_operation
-        conds: List[cirq.Condition] = []
+        conds: list[cirq.Condition] = []
         for c in conditions:
             if isinstance(c, str):
                 c = value.MeasurementKey.parse_serialized(c)
@@ -118,11 +106,11 @@ class ClassicallyControlledOperation(raw_types.Operation):
             if isinstance(c, sympy.Basic):
                 c = value.SympyCondition(c)
             conds.append(c)
-        self._conditions: Tuple[cirq.Condition, ...] = tuple(conds)
+        self._conditions: tuple[cirq.Condition, ...] = tuple(conds)
         self._sub_operation: cirq.Operation = sub_operation
 
     @property
-    def classical_controls(self) -> FrozenSet[cirq.Condition]:
+    def classical_controls(self) -> frozenset[cirq.Condition]:
         return frozenset(self._conditions).union(self._sub_operation.classical_controls)
 
     def without_classical_controls(self) -> cirq.Operation:
@@ -140,7 +128,7 @@ class ClassicallyControlledOperation(raw_types.Operation):
     def _decompose_(self):
         return self._decompose_with_context_()
 
-    def _decompose_with_context_(self, context: Optional[cirq.DecompositionContext] = None):
+    def _decompose_with_context_(self, context: cirq.DecompositionContext | None = None):
         result = protocols.decompose_once(
             self._sub_operation, NotImplemented, flatten=False, context=context
         )
@@ -178,7 +166,7 @@ class ClassicallyControlledOperation(raw_types.Operation):
 
     def _circuit_diagram_info_(
         self, args: cirq.CircuitDiagramInfoArgs
-    ) -> Optional[protocols.CircuitDiagramInfo]:
+    ) -> protocols.CircuitDiagramInfo | None:
         sub_args = protocols.CircuitDiagramInfoArgs(
             known_qubit_count=args.known_qubit_count,
             known_qubits=args.known_qubits,
@@ -210,7 +198,7 @@ class ClassicallyControlledOperation(raw_types.Operation):
             wire_symbols=wire_symbols, exponent=sub_info.exponent, exponent_qubit_index=exp_index
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'conditions': self._conditions, 'sub_operation': self._sub_operation}
 
     def _act_on_(self, sim_state: cirq.SimulationStateBase) -> bool:
@@ -226,26 +214,26 @@ class ClassicallyControlledOperation(raw_types.Operation):
         sub_operation = self._sub_operation if sub_operation is NotImplemented else sub_operation
         return sub_operation.with_classical_controls(*conditions)
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]) -> ClassicallyControlledOperation:
+    def _with_key_path_prefix_(self, prefix: tuple[str, ...]) -> ClassicallyControlledOperation:
         conditions = [protocols.with_key_path_prefix(c, prefix) for c in self._conditions]
         sub_operation = protocols.with_key_path_prefix(self._sub_operation, prefix)
         sub_operation = self._sub_operation if sub_operation is NotImplemented else sub_operation
         return sub_operation.with_classical_controls(*conditions)
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
+        self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]
     ) -> ClassicallyControlledOperation:
         conds = [protocols.with_rescoped_keys(c, path, bindable_keys) for c in self._conditions]
         sub_operation = protocols.with_rescoped_keys(self._sub_operation, path, bindable_keys)
         return sub_operation.with_classical_controls(*conds)
 
-    def _control_keys_(self) -> FrozenSet[cirq.MeasurementKey]:
-        local_keys: FrozenSet[cirq.MeasurementKey] = frozenset(
+    def _control_keys_(self) -> frozenset[cirq.MeasurementKey]:
+        local_keys: frozenset[cirq.MeasurementKey] = frozenset(
             k for condition in self._conditions for k in condition.keys
         )
         return local_keys.union(protocols.control_keys(self._sub_operation))
 
-    def _qasm_(self, args: cirq.QasmArgs) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs) -> str | None:
         args.validate_version('2.0', '3.0')
         if len(self._conditions) > 1:
             raise ValueError('QASM does not support multiple conditions.')

cirq/ops/clifford_gate.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import functools
 from dataclasses import dataclass
 from types import NotImplementedType
-from typing import Any, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -36,7 +36,7 @@ sim = LazyLoader("sim", globals(), "cirq.sim")
 transformers = LazyLoader("transformers", globals(), "cirq.transformers")
 
 
-def _to_pauli_tuple(matrix: np.ndarray) -> Optional[Tuple[Pauli, bool]]:
+def _to_pauli_tuple(matrix: np.ndarray) -> tuple[Pauli, bool] | None:
     """Converts matrix to Pauli gate.
 
     If matrix is not ±Pauli matrix, returns None.
@@ -51,10 +51,10 @@ def _to_pauli_tuple(matrix: np.ndarray) -> Optional[Tuple[Pauli, bool]]:
 
 
 def _to_clifford_tableau(
-    rotation_map: Optional[Dict[Pauli, Tuple[Pauli, bool]]] = None,
+    rotation_map: dict[Pauli, tuple[Pauli, bool]] | None = None,
     *,
-    x_to: Optional[Tuple[Pauli, bool]] = None,
-    z_to: Optional[Tuple[Pauli, bool]] = None,
+    x_to: tuple[Pauli, bool] | None = None,
+    z_to: tuple[Pauli, bool] | None = None,
 ) -> qis.CliffordTableau:
     """Transfer the rotation map to clifford tableau representation"""
     if x_to is None and z_to is None and rotation_map is None:
@@ -81,11 +81,11 @@ def _to_clifford_tableau(
 
 def _validate_map_input(
     required_transform_count: int,
-    pauli_map_to: Optional[Dict[Pauli, Tuple[Pauli, bool]]],
-    x_to: Optional[Tuple[Pauli, bool]],
-    y_to: Optional[Tuple[Pauli, bool]],
-    z_to: Optional[Tuple[Pauli, bool]],
-) -> Dict[Pauli, Tuple[Pauli, bool]]:
+    pauli_map_to: dict[Pauli, tuple[Pauli, bool]] | None,
+    x_to: tuple[Pauli, bool] | None,
+    y_to: tuple[Pauli, bool] | None,
+    z_to: tuple[Pauli, bool] | None,
+) -> dict[Pauli, tuple[Pauli, bool]]:
     if pauli_map_to is None:
         xyz_to = {pauli_gates.X: x_to, pauli_gates.Y: y_to, pauli_gates.Z: z_to}
         pauli_map_to = {p: trans for p, trans in xyz_to.items() if trans is not None}
@@ -110,7 +110,7 @@ def _validate_map_input(
 
 
 def _pad_tableau(
-    clifford_tableau: qis.CliffordTableau, num_qubits_after_padding: int, axes: List[int]
+    clifford_tableau: qis.CliffordTableau, num_qubits_after_padding: int, axes: list[int]
 ) -> qis.CliffordTableau:
     """Roughly, this function copies self.tableau into the "identity" matrix."""
     # Sanity check
@@ -334,7 +334,7 @@ class CommonCliffordGates(metaclass=CommonCliffordGateMetaClass):
         return cls(_clifford_tableau=_clifford_tableau)
 
     @classmethod
-    def _get_sqrt_map(cls) -> Dict[float, Dict[SingleQubitCliffordGate, SingleQubitCliffordGate]]:
+    def _get_sqrt_map(cls) -> dict[float, dict[SingleQubitCliffordGate, SingleQubitCliffordGate]]:
         """Returns a map containing two keys 0.5 and -0.5 for the sqrt mapping of Pauli gates."""
         return {
             0.5: {cls.X: cls.X_sqrt, cls.Y: cls.Y_sqrt, cls.Z: cls.Z_sqrt},
@@ -377,7 +377,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
     def clifford_tableau(self):
         return self._clifford_tableau
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         json_dict = self._clifford_tableau._json_dict_()
         return json_dict
 
@@ -387,7 +387,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
     def _num_qubits_(self):
         return self.clifford_tableau.n
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         # By definition, Clifford Gate should always return True.
         return True
 
@@ -426,9 +426,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
     def __repr__(self) -> str:
         return f"Clifford Gate with Tableau:\n{self.clifford_tableau._str_full_()}"
 
-    def _commutes_(
-        self, other: Any, *, atol: float = 1e-8
-    ) -> Union[bool, NotImplementedType, None]:
+    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> bool | NotImplementedType | None:
         # Note even if we assume two gates define the tableau based on the same qubit order,
         # the following approach cannot judge it:
         # self.clifford_tableau.then(other.clifford_tableau) == other.clifford_tableau.then(
@@ -445,7 +443,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
 
     def _act_on_(
         self, sim_state: cirq.SimulationStateBase, qubits: Sequence[cirq.Qid]
-    ) -> Union[NotImplementedType, bool]:
+    ) -> NotImplementedType | bool:
         # Note the computation complexity difference between _decompose_ and _act_on_.
         # Suppose this Gate has `m` qubits, args has `n` qubits, and the decomposition of
         # this operation into `k` operations:
@@ -493,7 +491,7 @@ class SingleQubitCliffordGate(CliffordGate):
         return SingleQubitCliffordGate(_clifford_tableau=tableau)
 
     @staticmethod
-    def from_xz_map(x_to: Tuple[Pauli, bool], z_to: Tuple[Pauli, bool]) -> SingleQubitCliffordGate:
+    def from_xz_map(x_to: tuple[Pauli, bool], z_to: tuple[Pauli, bool]) -> SingleQubitCliffordGate:
         """Returns a SingleQubitCliffordGate for the specified transforms.
         The Y transform is derived from the X and Z.
 
@@ -507,11 +505,11 @@ class SingleQubitCliffordGate(CliffordGate):
 
     @staticmethod
     def from_single_map(
-        pauli_map_to: Optional[Dict[Pauli, Tuple[Pauli, bool]]] = None,
+        pauli_map_to: dict[Pauli, tuple[Pauli, bool]] | None = None,
         *,
-        x_to: Optional[Tuple[Pauli, bool]] = None,
-        y_to: Optional[Tuple[Pauli, bool]] = None,
-        z_to: Optional[Tuple[Pauli, bool]] = None,
+        x_to: tuple[Pauli, bool] | None = None,
+        y_to: tuple[Pauli, bool] | None = None,
+        z_to: tuple[Pauli, bool] | None = None,
     ) -> SingleQubitCliffordGate:
         """Returns a SingleQubitCliffordGate for the
         specified transform with a 90 or 180 degree rotation.
@@ -540,11 +538,11 @@ class SingleQubitCliffordGate(CliffordGate):
 
     @staticmethod
     def from_double_map(
-        pauli_map_to: Optional[Dict[Pauli, Tuple[Pauli, bool]]] = None,
+        pauli_map_to: dict[Pauli, tuple[Pauli, bool]] | None = None,
         *,
-        x_to: Optional[Tuple[Pauli, bool]] = None,
-        y_to: Optional[Tuple[Pauli, bool]] = None,
-        z_to: Optional[Tuple[Pauli, bool]] = None,
+        x_to: tuple[Pauli, bool] | None = None,
+        y_to: tuple[Pauli, bool] | None = None,
+        z_to: tuple[Pauli, bool] | None = None,
     ) -> SingleQubitCliffordGate:
         """Returns a SingleQubitCliffordGate for the
         specified transform with a 90 or 180 degree rotation.
@@ -598,7 +596,7 @@ class SingleQubitCliffordGate(CliffordGate):
         return SingleQubitCliffordGate.from_pauli(pauli, True) ** -1
 
     @staticmethod
-    def from_unitary(u: np.ndarray) -> Optional[SingleQubitCliffordGate]:
+    def from_unitary(u: np.ndarray) -> SingleQubitCliffordGate | None:
         """Creates Clifford gate with given unitary (up to global phase).
 
         Args:
@@ -624,7 +622,7 @@ class SingleQubitCliffordGate(CliffordGate):
     @classmethod
     def from_unitary_with_global_phase(
         cls, u: np.ndarray
-    ) -> Optional[Tuple[SingleQubitCliffordGate, complex]]:
+    ) -> tuple[SingleQubitCliffordGate, complex] | None:
         """Creates Clifford gate with given unitary, including global phase.
 
         Args:
@@ -644,7 +642,7 @@ class SingleQubitCliffordGate(CliffordGate):
         k = max(np.ndindex(*u.shape), key=lambda t: abs(u[t]))
         return gate, u[k] / protocols.unitary(gate)[k]
 
-    def pauli_tuple(self, pauli: Pauli) -> Tuple[Pauli, bool]:
+    def pauli_tuple(self, pauli: Pauli) -> tuple[Pauli, bool]:
         """Returns a tuple of a Pauli operator and a boolean.
 
         The pauli is the operator of the transform and the boolean
@@ -762,9 +760,7 @@ class SingleQubitCliffordGate(CliffordGate):
         (qubit,) = qubits
         return tuple(gate.on(qubit) for gate in self.decompose_gate())
 
-    def _commutes_(
-        self, other: Any, *, atol: float = 1e-8
-    ) -> Union[bool, NotImplementedType, None]:
+    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> bool | NotImplementedType | None:
         if isinstance(other, SingleQubitCliffordGate):
             return self.commutes_with_single_qubit_gate(other)
         if isinstance(other, Pauli):
@@ -822,7 +818,7 @@ class SingleQubitCliffordGate(CliffordGate):
         rotations = self.decompose_rotation()
         return [r ** (qt / 2) for r, qt in rotations]
 
-    def decompose_rotation(self) -> Sequence[Tuple[Pauli, int]]:
+    def decompose_rotation(self) -> Sequence[tuple[Pauli, int]]:
         """Decomposes this clifford into a series of pauli rotations.
 
         Each rotation is given as a tuple of (axis, quarter_turns),
@@ -835,7 +831,7 @@ class SingleQubitCliffordGate(CliffordGate):
         return self._decompose_rotation
 
     @functools.cached_property
-    def _decompose_rotation(self) -> Sequence[Tuple[Pauli, int]]:
+    def _decompose_rotation(self) -> Sequence[tuple[Pauli, int]]:
         x_rot = self.pauli_tuple(pauli_gates.X)
         y_rot = self.pauli_tuple(pauli_gates.Y)
         z_rot = self.pauli_tuple(pauli_gates.Z)

cirq/ops/clifford_gate_test.py

@@ -16,7 +16,6 @@ from __future__ import annotations
 
 import functools
 import itertools
-from typing import Tuple, Type
 
 import numpy as np
 import pytest
@@ -61,7 +60,7 @@ def _all_rotation_pairs():
 
 
 @functools.lru_cache()
-def _all_clifford_gates() -> Tuple[cirq.SingleQubitCliffordGate, ...]:
+def _all_clifford_gates() -> tuple[cirq.SingleQubitCliffordGate, ...]:
     return tuple(
         cirq.SingleQubitCliffordGate.from_xz_map(trans_x, trans_z)
         for trans_x, trans_z in _all_rotation_pairs()
@@ -430,7 +429,7 @@ def test_known_matrix(gate, gate_equiv):
         ('SWAP', cirq.CliffordGate),
     ],
 )
-def test_common_clifford_types(name: str, expected_cls: Type) -> None:
+def test_common_clifford_types(name: str, expected_cls: type) -> None:
     assert isinstance(getattr(cirq.CliffordGate, name), expected_cls)
     assert isinstance(getattr(cirq.SingleQubitCliffordGate, name), expected_cls)
 

cirq/ops/common_channels.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, Iterable, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -53,10 +53,10 @@ class AsymmetricDepolarizingChannel(raw_types.Gate):
 
     def __init__(
         self,
-        p_x: Optional[float] = None,
-        p_y: Optional[float] = None,
-        p_z: Optional[float] = None,
-        error_probabilities: Optional[Dict[str, float]] = None,
+        p_x: float | None = None,
+        p_y: float | None = None,
+        p_z: float | None = None,
+        error_probabilities: dict[str, float] | None = None,
         tol: float = 1e-8,
     ) -> None:
         r"""The asymmetric depolarizing channel.
@@ -110,7 +110,7 @@ class AsymmetricDepolarizingChannel(raw_types.Gate):
             self._num_qubits = 1
             self._error_probabilities = {'I': p_i, 'X': p_x, 'Y': p_y, 'Z': p_z}
 
-    def _mixture_(self) -> Sequence[Tuple[float, np.ndarray]]:
+    def _mixture_(self) -> Sequence[tuple[float, np.ndarray]]:
         ps = []
         for pauli in self._error_probabilities:
             Pi = np.identity(1)
@@ -141,9 +141,7 @@ class AsymmetricDepolarizingChannel(raw_types.Gate):
     def __str__(self) -> str:
         return 'asymmetric_depolarize(' + f"error_probabilities={self._error_probabilities})"
 
-    def _circuit_diagram_info_(
-        self, args: protocols.CircuitDiagramInfoArgs
-    ) -> Union[str, Iterable[str]]:
+    def _circuit_diagram_info_(self, args: protocols.CircuitDiagramInfoArgs) -> str | Iterable[str]:
         if self._num_qubits == 1:
             if args.precision is not None:
                 return (
@@ -191,19 +189,19 @@ class AsymmetricDepolarizingChannel(raw_types.Gate):
         return self._error_probabilities.get('Z', 0.0)
 
     @property
-    def error_probabilities(self) -> Dict[str, float]:
+    def error_probabilities(self) -> dict[str, float]:
         """A dictionary from Pauli gates to probability"""
         return self._error_probabilities
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['error_probabilities'])
 
 
 def asymmetric_depolarize(
-    p_x: Optional[float] = None,
-    p_y: Optional[float] = None,
-    p_z: Optional[float] = None,
-    error_probabilities: Optional[Dict[str, float]] = None,
+    p_x: float | None = None,
+    p_y: float | None = None,
+    p_z: float | None = None,
+    error_probabilities: dict[str, float] | None = None,
     tol: float = 1e-8,
 ) -> AsymmetricDepolarizingChannel:
     r"""Returns an `AsymmetricDepolarizingChannel` with the given parameters.
@@ -296,7 +294,7 @@ class DepolarizingChannel(raw_types.Gate):
     def _qid_shape_(self):
         return (2,) * self._n_qubits
 
-    def _mixture_(self) -> Sequence[Tuple[float, np.ndarray]]:
+    def _mixture_(self) -> Sequence[tuple[float, np.ndarray]]:
         return self._delegate._mixture_()
 
     def _has_mixture_(self) -> bool:
@@ -315,8 +313,8 @@ class DepolarizingChannel(raw_types.Gate):
             return f"depolarize(p={self._p})"
         return f"depolarize(p={self._p},n_qubits={self._n_qubits})"
 
-    def _circuit_diagram_info_(self, args: protocols.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
-        result: Tuple[str, ...]
+    def _circuit_diagram_info_(self, args: protocols.CircuitDiagramInfoArgs) -> tuple[str, ...]:
+        result: tuple[str, ...]
         if args.precision is not None:
             result = (f"D({self._p:.{args.precision}g})",)
         else:
@@ -339,7 +337,7 @@ class DepolarizingChannel(raw_types.Gate):
         """The number of qubits"""
         return self._n_qubits
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         if self._n_qubits == 1:
             return protocols.obj_to_dict_helper(self, ['p'])
         return protocols.obj_to_dict_helper(self, ['p', 'n_qubits'])
@@ -480,7 +478,7 @@ class GeneralizedAmplitudeDampingChannel(raw_types.Gate):
         """The probability of energy transfer."""
         return self._gamma
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['p', 'gamma'])
 
 
@@ -604,7 +602,7 @@ class AmplitudeDampingChannel(raw_types.Gate):
         """The probability of the interaction being dissipative."""
         return self._gamma
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['gamma'])
 
 
@@ -683,10 +681,10 @@ class ResetChannel(raw_types.Gate):
         """
         self._dimension = dimension
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         return True
 
-    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         args.validate_version('2.0', '3.0')
         return args.format('reset {0};\n', qubits[0])
 
@@ -752,7 +750,7 @@ class ResetChannel(raw_types.Gate):
         """The dimension of the qudit being reset."""
         return self._dimension
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['dimension'])
 
 
@@ -767,7 +765,7 @@ def reset(qubit: cirq.Qid) -> raw_types.Operation:
 R = reset
 
 
-def reset_each(*qubits: cirq.Qid) -> List[raw_types.Operation]:
+def reset_each(*qubits: cirq.Qid) -> list[raw_types.Operation]:
     """Returns a list of `cirq.ResetChannel` instances on the given qubits."""
     return [ResetChannel(q.dimension).on(q) for q in qubits]
 
@@ -863,7 +861,7 @@ class PhaseDampingChannel(raw_types.Gate):
         """The damping constant."""
         return self._gamma
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['gamma'])
 
 
@@ -942,7 +940,7 @@ class PhaseFlipChannel(raw_types.Gate):
     def _num_qubits_(self) -> int:
         return 1
 
-    def _mixture_(self) -> Sequence[Tuple[float, np.ndarray]]:
+    def _mixture_(self) -> Sequence[tuple[float, np.ndarray]]:
         mixture = self._delegate._mixture_()
         # just return identity and z term
         return (mixture[0], mixture[3])
@@ -970,7 +968,7 @@ class PhaseFlipChannel(raw_types.Gate):
         """The probability of a phase flip."""
         return self._p
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['p'])
 
 
@@ -1013,7 +1011,7 @@ def _phase_flip(p: float) -> PhaseFlipChannel:
     return PhaseFlipChannel(p)
 
 
-def phase_flip(p: Optional[float] = None) -> Union[common_gates.ZPowGate, PhaseFlipChannel]:
+def phase_flip(p: float | None = None) -> common_gates.ZPowGate | PhaseFlipChannel:
     r"""Returns a PhaseFlipChannel that flips a qubit's phase with probability p.
 
     If `p` is None, return a guaranteed phase flip in the form of a Z operation.
@@ -1095,7 +1093,7 @@ class BitFlipChannel(raw_types.Gate):
     def _num_qubits_(self) -> int:
         return 1
 
-    def _mixture_(self) -> Sequence[Tuple[float, Any]]:
+    def _mixture_(self) -> Sequence[tuple[float, Any]]:
         return ((1 - self._p, identity.I), (self._p, pauli_gates.X))
 
     def _has_mixture_(self) -> bool:
@@ -1121,7 +1119,7 @@ class BitFlipChannel(raw_types.Gate):
         """The probability of a bit flip."""
         return self._p
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['p'])
 
 
@@ -1159,7 +1157,7 @@ def _bit_flip(p: float) -> BitFlipChannel:
     return BitFlipChannel(p)
 
 
-def bit_flip(p: Optional[float] = None) -> Union[common_gates.XPowGate, BitFlipChannel]:
+def bit_flip(p: float | None = None) -> common_gates.XPowGate | BitFlipChannel:
     r"""Construct a BitFlipChannel that flips a qubit state with probability p.
 
     If p is None, this returns a guaranteed flip in the form of an X operation.