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

cirq/ops/op_tree.py

@@ -14,7 +14,9 @@
 
 """A recursive type describing trees of operations, and utility methods for it."""
 
-from typing import Callable, Iterable, Iterator, NoReturn, TYPE_CHECKING, Union
+from __future__ import annotations
+
+from typing import Callable, Iterable, Iterator, NoReturn, TYPE_CHECKING
 
 from cirq._doc import document
 from cirq._import import LazyLoader
@@ -26,7 +28,7 @@ if TYPE_CHECKING:
 moment = LazyLoader("moment", globals(), "cirq.circuits.moment")
 
 
-OP_TREE = Union[Operation, Iterable['OP_TREE']]
+OP_TREE = Operation | Iterable['OP_TREE']
 document(
     OP_TREE,
     """An operation or nested collections of operations.
@@ -35,10 +37,10 @@ document(
     `cirq.OP_TREE` argument:
 
     - A single operation (a `cirq.Operation`).
-    - A list of operations (a `List[cirq.Operation]`).
-    - A list of lists of operations (a `List[List[cirq.Operation]]`).
+    - A list of operations (a `list[cirq.Operation]`).
+    - A list of lists of operations (a `list[list[cirq.Operation]]`).
     - A list mixing operations and generators of operations
-        (a `List[Union[cirq.Operation, Iterator[cirq.Operation]]]`).
+        (a `list[cirq.Operation | Iterator[cirq.Operation]]`).
     - Generally anything that can be iterated, and its items iterated, and
         so forth recursively until a bottom layer of operations is found.
     """,
@@ -47,7 +49,7 @@ document(
 
 def flatten_op_tree(
     root: OP_TREE, preserve_moments: bool = False
-) -> Iterator[Union[Operation, 'cirq.Moment']]:
+) -> Iterator[Operation | cirq.Moment]:
     """Performs an in-order iteration of the operations (leaves) in an OP_TREE.
 
     Args:
@@ -88,7 +90,7 @@ def flatten_to_ops(root: OP_TREE) -> Iterator[Operation]:
         _bad_op_tree(root)
 
 
-def flatten_to_ops_or_moments(root: OP_TREE) -> Iterator[Union[Operation, 'cirq.Moment']]:
+def flatten_to_ops_or_moments(root: OP_TREE) -> Iterator[Operation | cirq.Moment]:
     """Performs an in-order iteration OP_TREE, yielding ops and moments.
 
     Args:

cirq/ops/op_tree_test.py

@@ -11,6 +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 cast
 
 import pytest
@@ -18,7 +21,7 @@ import pytest
 import cirq
 
 
-def test_flatten_op_tree():
+def test_flatten_op_tree() -> None:
     operations = [
         cirq.GateOperation(cirq.testing.SingleQubitGate(), [cirq.NamedQubit(str(i))])
         for i in range(10)
@@ -46,33 +49,33 @@ def test_flatten_op_tree():
 
     # Bad trees.
     with pytest.raises(TypeError):
-        _ = list(cirq.flatten_op_tree(None))
+        _ = list(cirq.flatten_op_tree(None))  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        _ = list(cirq.flatten_op_tree(5))
+        _ = list(cirq.flatten_op_tree(5))  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        _ = list(cirq.flatten_op_tree([operations[0], (4,)]))
+        _ = list(cirq.flatten_op_tree([operations[0], (4,)]))  # type: ignore[list-item]
 
 
-def test_flatten_to_ops_or_moments():
+def test_flatten_to_ops_or_moments() -> None:
     operations = [
         cirq.GateOperation(cirq.testing.SingleQubitGate(), [cirq.NamedQubit(str(i))])
         for i in range(10)
     ]
-    op_tree = [operations[0], cirq.Moment(operations[1:5]), operations[5:]]
+    op_tree: cirq.OP_TREE = [operations[0], cirq.Moment(operations[1:5]), operations[5:]]
     output = [operations[0], cirq.Moment(operations[1:5])] + operations[5:]
     assert list(cirq.flatten_to_ops_or_moments(op_tree)) == output
     assert list(cirq.flatten_op_tree(op_tree, preserve_moments=True)) == output
 
     # Bad trees.
     with pytest.raises(TypeError):
-        _ = list(cirq.flatten_to_ops_or_moments(None))
+        _ = list(cirq.flatten_to_ops_or_moments(None))  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        _ = list(cirq.flatten_to_ops_or_moments(5))
+        _ = list(cirq.flatten_to_ops_or_moments(5))  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        _ = list(cirq.flatten_to_ops_or_moments([operations[0], (4,)]))
+        _ = list(cirq.flatten_to_ops_or_moments([operations[0], (4,)]))  # type: ignore[list-item]
 
 
-def test_freeze_op_tree():
+def test_freeze_op_tree() -> None:
     operations = [
         cirq.GateOperation(cirq.testing.SingleQubitGate(), [cirq.NamedQubit(str(i))])
         for i in range(10)
@@ -94,29 +97,29 @@ def test_freeze_op_tree():
 
     # Bad trees.
     with pytest.raises(TypeError):
-        cirq.freeze_op_tree(None)
+        cirq.freeze_op_tree(None)  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        cirq.freeze_op_tree(5)
+        cirq.freeze_op_tree(5)  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        _ = cirq.freeze_op_tree([operations[0], (4,)])
+        _ = cirq.freeze_op_tree([operations[0], (4,)])  # type: ignore[list-item]
 
 
-def test_transform_bad_tree():
+def test_transform_bad_tree() -> None:
     with pytest.raises(TypeError):
-        _ = list(cirq.transform_op_tree(None))
+        _ = list(cirq.transform_op_tree(None))  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        _ = list(cirq.transform_op_tree(5))
+        _ = list(cirq.transform_op_tree(5))  # type: ignore[arg-type]
     with pytest.raises(TypeError):
         _ = list(
             cirq.flatten_op_tree(
                 cirq.transform_op_tree(
-                    [cirq.GateOperation(cirq.Gate(), [cirq.NamedQubit('q')]), (4,)]
+                    [cirq.GateOperation(cirq.Gate(), [cirq.NamedQubit('q')]), (4,)]  # type: ignore
                 )
             )
         )
 
 
-def test_transform_leaves():
+def test_transform_leaves() -> None:
     gs = [cirq.testing.SingleQubitGate() for _ in range(10)]
     operations = [cirq.GateOperation(gs[i], [cirq.NamedQubit(str(i))]) for i in range(10)]
     expected = [cirq.GateOperation(gs[i], [cirq.NamedQubit(str(i) + 'a')]) for i in range(10)]
@@ -150,7 +153,7 @@ def test_transform_leaves():
     )
 
 
-def test_transform_internal_nodes():
+def test_transform_internal_nodes() -> None:
     operations = [
         cirq.GateOperation(cirq.testing.SingleQubitGate(), [cirq.LineQubit(2 * i)])
         for i in range(10)

cirq/ops/parallel_gate.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from types import NotImplementedType
-from typing import AbstractSet, Any, Dict, Optional, Tuple, TYPE_CHECKING, Union
+from typing import AbstractSet, Any, TYPE_CHECKING
 
 import numpy as np
 
@@ -29,7 +31,7 @@ if TYPE_CHECKING:
 class ParallelGate(raw_types.Gate):
     """Augments existing gates to be applied on one or more groups of qubits."""
 
-    def __init__(self, sub_gate: 'cirq.Gate', num_copies: int) -> None:
+    def __init__(self, sub_gate: cirq.Gate, num_copies: int) -> None:
         """Inits ParallelGate.
 
         Args:
@@ -52,24 +54,24 @@ class ParallelGate(raw_types.Gate):
         return self.sub_gate.num_qubits() * self._num_copies
 
     @property
-    def sub_gate(self) -> 'cirq.Gate':
+    def sub_gate(self) -> cirq.Gate:
         return self._sub_gate
 
     @property
     def num_copies(self) -> int:
         return self._num_copies
 
-    def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> 'DecomposeResult':
+    def _decompose_(self, qubits: tuple[cirq.Qid, ...]) -> DecomposeResult:
         if len(qubits) != self.num_qubits():
             raise ValueError(f"len(qubits)={len(qubits)} should be {self.num_qubits()}")
         step = self.sub_gate.num_qubits()
         return [self.sub_gate(*qubits[i : i + step]) for i in range(0, len(qubits), step)]
 
-    def with_gate(self, sub_gate: 'cirq.Gate') -> 'ParallelGate':
+    def with_gate(self, sub_gate: cirq.Gate) -> ParallelGate:
         """ParallelGate with same number of copies but a new gate"""
         return ParallelGate(sub_gate, self._num_copies)
 
-    def with_num_copies(self, num_copies: int) -> 'ParallelGate':
+    def with_num_copies(self, num_copies: int) -> ParallelGate:
         """ParallelGate with same sub_gate but different num_copies"""
         return ParallelGate(self.sub_gate, num_copies)
 
@@ -91,14 +93,12 @@ class ParallelGate(raw_types.Gate):
     def _parameter_names_(self) -> AbstractSet[str]:
         return protocols.parameter_names(self.sub_gate)
 
-    def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'ParallelGate':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> ParallelGate:
         return self.with_gate(
             sub_gate=protocols.resolve_parameters(self.sub_gate, resolver, recursive)
         )
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         # Obtain the unitary for the single qubit gate
         single_unitary = protocols.unitary(self.sub_gate, NotImplemented)
 
@@ -114,7 +114,7 @@ class ParallelGate(raw_types.Gate):
 
         return unitary
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if protocols.is_parameterized(self.sub_gate):
             return None
         angle = self._num_copies * np.arcsin(protocols.trace_distance_bound(self.sub_gate))
@@ -122,9 +122,7 @@ class ParallelGate(raw_types.Gate):
             return 1.0
         return np.sin(angle)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         diagram_info = protocols.circuit_diagram_info(self.sub_gate, args, NotImplemented)
         if diagram_info == NotImplemented:
             return diagram_info
@@ -136,7 +134,7 @@ class ParallelGate(raw_types.Gate):
             wire_symbols=wire_symbols, exponent=diagram_info.exponent, connected=False
         )
 
-    def __pow__(self, exponent: Any) -> 'ParallelGate':
+    def __pow__(self, exponent: Any) -> ParallelGate:
         """Raises underlying gate to a power, applying same number of copies.
 
         For extrapolatable gate G this means the following two are equivalent:
@@ -154,11 +152,11 @@ class ParallelGate(raw_types.Gate):
             return NotImplemented
         return self.with_gate(new_gate)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, attribute_names=["sub_gate", "num_copies"])
 
 
-def parallel_gate_op(gate: 'cirq.Gate', *targets: 'cirq.Qid') -> 'cirq.Operation':
+def parallel_gate_op(gate: cirq.Gate, *targets: cirq.Qid) -> cirq.Operation:
     """Constructs a ParallelGate using gate and applies to all given qubits
 
     Args:

cirq/ops/parallel_gate_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
 import sympy
@@ -26,7 +28,7 @@ import cirq
         (cirq.X**0.5, 4, cirq.LineQubit.range(4)),
     ],
 )
-def test_parallel_gate_operation_init(gate, num_copies, qubits):
+def test_parallel_gate_operation_init(gate, num_copies, qubits) -> None:
     v = cirq.ParallelGate(gate, num_copies)
     assert v.sub_gate == gate
     assert v.num_copies == num_copies
@@ -52,7 +54,7 @@ def test_parallel_gate_operation_init(gate, num_copies, qubits):
         (cirq.testing.TwoQubitGate(), 2, cirq.LineQubit.range(4), "must be a single qubit gate"),
     ],
 )
-def test_invalid_parallel_gate_operation(gate, num_copies, qubits, error_msg):
+def test_invalid_parallel_gate_operation(gate, num_copies, qubits, error_msg) -> None:
     with pytest.raises(ValueError, match=error_msg):
         cirq.ParallelGate(gate, num_copies)(*qubits)
 
@@ -61,27 +63,27 @@ def test_invalid_parallel_gate_operation(gate, num_copies, qubits, error_msg):
     'gate, num_copies, qubits',
     [(cirq.X, 2, cirq.LineQubit.range(2)), (cirq.H**0.5, 4, cirq.LineQubit.range(4))],
 )
-def test_decompose(gate, num_copies, qubits):
+def test_decompose(gate, num_copies, qubits) -> None:
     g = cirq.ParallelGate(gate, num_copies)
     step = gate.num_qubits()
     qubit_lists = [qubits[i * step : (i + 1) * step] for i in range(num_copies)]
     assert set(cirq.decompose_once(g(*qubits))) == set(gate.on_each(qubit_lists))
 
 
-def test_decompose_raises():
+def test_decompose_raises() -> None:
     g = cirq.ParallelGate(cirq.X, 2)
     qubits = cirq.LineQubit.range(4)
     with pytest.raises(ValueError, match=r'len\(qubits\)=4 should be 2'):
         cirq.decompose_once_with_qubits(g, qubits)
 
 
-def test_with_num_copies():
+def test_with_num_copies() -> None:
     g = cirq.testing.SingleQubitGate()
     pg = cirq.ParallelGate(g, 3)
     assert pg.with_num_copies(5) == cirq.ParallelGate(g, 5)
 
 
-def test_extrapolate():
+def test_extrapolate() -> None:
     # If the gate isn't extrapolatable, you get a type error.
     g = cirq.ParallelGate(cirq.testing.SingleQubitGate(), 2)
     with pytest.raises(TypeError):
@@ -93,7 +95,7 @@ def test_extrapolate():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_parameterizable_gates(resolve_fn):
+def test_parameterizable_gates(resolve_fn) -> None:
     r = cirq.ParamResolver({'a': 0.5})
     g1 = cirq.ParallelGate(cirq.Z ** sympy.Symbol('a'), 2)
     assert cirq.is_parameterized(g1)
@@ -102,7 +104,7 @@ def test_parameterizable_gates(resolve_fn):
 
 
 @pytest.mark.parametrize('gate', [cirq.X ** sympy.Symbol("a"), cirq.testing.SingleQubitGate()])
-def test_no_unitary(gate):
+def test_no_unitary(gate) -> None:
     g = cirq.ParallelGate(gate, 2)
     assert not cirq.has_unitary(g)
     assert cirq.unitary(g, None) is None
@@ -115,7 +117,7 @@ def test_no_unitary(gate):
         (cirq.MatrixGate(cirq.unitary(cirq.H**0.25)), 6, cirq.LineQubit.range(6)),
     ],
 )
-def test_unitary(gate, num_copies, qubits):
+def test_unitary(gate, num_copies, qubits) -> None:
     g = cirq.ParallelGate(gate, num_copies)
     step = gate.num_qubits()
     qubit_lists = [qubits[i * step : (i + 1) * step] for i in range(num_copies)]
@@ -124,7 +126,7 @@ def test_unitary(gate, num_copies, qubits):
     )
 
 
-def test_not_implemented_diagram():
+def test_not_implemented_diagram() -> None:
     q = cirq.LineQubit.range(2)
     g = cirq.testing.SingleQubitGate()
     c = cirq.Circuit()
@@ -132,15 +134,15 @@ def test_not_implemented_diagram():
     assert 'cirq.testing.gate_features.SingleQubitGate ' in str(c)
 
 
-def test_repr():
+def test_repr() -> None:
     assert repr(cirq.ParallelGate(cirq.X, 2)) == 'cirq.ParallelGate(sub_gate=cirq.X, num_copies=2)'
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.ParallelGate(cirq.X**0.5, 10)) == 'X**0.5 x 10'
 
 
-def test_equivalent_circuit():
+def test_equivalent_circuit() -> None:
     qreg = cirq.LineQubit.range(4)
     oldc = cirq.Circuit()
     newc = cirq.Circuit()
@@ -154,11 +156,11 @@ def test_equivalent_circuit():
 
 
 @pytest.mark.parametrize('gate, num_copies', [(cirq.X, 1), (cirq.Y, 2), (cirq.Z, 3), (cirq.H, 4)])
-def test_parallel_gate_operation_is_consistent(gate, num_copies):
+def test_parallel_gate_operation_is_consistent(gate, num_copies) -> None:
     cirq.testing.assert_implements_consistent_protocols(cirq.ParallelGate(gate, num_copies))
 
 
-def test_trace_distance():
+def test_trace_distance() -> None:
     s = cirq.X**0.25
     two_g = cirq.ParallelGate(s, 2)
     three_g = cirq.ParallelGate(s, 3)
@@ -171,6 +173,6 @@ def test_trace_distance():
 
 
 @pytest.mark.parametrize('gate, num_copies', [(cirq.X, 1), (cirq.Y, 2), (cirq.Z, 3), (cirq.H, 4)])
-def test_parallel_gate_op(gate, num_copies):
+def test_parallel_gate_op(gate, num_copies) -> None:
     qubits = cirq.LineQubit.range(num_copies * gate.num_qubits())
     assert cirq.parallel_gate_op(gate, *qubits) == cirq.ParallelGate(gate, num_copies).on(*qubits)

cirq/ops/parity_gates.py

@@ -14,7 +14,9 @@
 
 """Quantum gates that phase with respect to product-of-pauli observables."""
 
-from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from __future__ import annotations
+
+from typing import Any, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 from typing_extensions import Self
@@ -71,7 +73,7 @@ class XXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def _num_qubits_(self) -> int:
         return 2
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [
             (
                 0.0,
@@ -88,7 +90,7 @@ class XXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def _eigen_shifts(self):
         return [0, 1]
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if self._is_parameterized_():
             return None
         return abs(np.sin(self._exponent * 0.5 * np.pi))
@@ -117,14 +119,14 @@ class XXPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def _has_stabilizer_effect_(self) -> bool:
         return self.exponent % 2 in (0, 0.5, 1, 1.5)
 
-    def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: tuple[cirq.Qid, ...]) -> Iterator[cirq.OP_TREE]:
         yield common_gates.YPowGate(exponent=-0.5).on_each(*qubits)
         yield ZZPowGate(exponent=self.exponent, global_shift=self.global_shift)(*qubits)
         yield common_gates.YPowGate(exponent=0.5).on_each(*qubits)
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Union[str, 'protocols.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> str | protocols.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(
             wire_symbols=('XX', 'XX'), exponent=self._diagram_exponent(args)
         )
@@ -178,7 +180,7 @@ class YYPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def _num_qubits_(self) -> int:
         return 2
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [
             (
                 0.0,
@@ -197,7 +199,7 @@ class YYPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def _eigen_shifts(self):
         return [0, 1]
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if self._is_parameterized_():
             return None
         return abs(np.sin(self._exponent * 0.5 * np.pi))
@@ -226,14 +228,12 @@ class YYPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def _has_stabilizer_effect_(self) -> bool:
         return self.exponent % 2 in (0, 0.5, 1, 1.5)
 
-    def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: tuple[cirq.Qid, ...]) -> Iterator[cirq.OP_TREE]:
         yield common_gates.XPowGate(exponent=0.5).on_each(*qubits)
         yield ZZPowGate(exponent=self.exponent, global_shift=self.global_shift)(*qubits)
         yield common_gates.XPowGate(exponent=-0.5).on_each(*qubits)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(
             wire_symbols=('YY', 'YY'), exponent=self._diagram_exponent(args)
         )
@@ -281,8 +281,8 @@ class ZZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         )(qubits[0], qubits[1])
 
     def _decompose_into_clifford_with_qubits_(
-        self, qubits: Sequence['cirq.Qid']
-    ) -> Sequence[Union['cirq.Operation', Sequence['cirq.Operation']]]:
+        self, qubits: Sequence[cirq.Qid]
+    ) -> Sequence[cirq.Operation | Sequence[cirq.Operation]]:
         if not self._has_stabilizer_effect_():
             return NotImplemented
         if self.exponent % 2 == 0:
@@ -308,25 +308,23 @@ class ZZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     def _has_stabilizer_effect_(self) -> bool:
         return self.exponent % 2 in (0, 0.5, 1, 1.5)
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 0, 0, 1])), (1, np.diag([0, 1, 1, 0]))]
 
     def _eigen_shifts(self):
         return [0, 1]
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if self._is_parameterized_():
             return None
         return abs(np.sin(self._exponent * 0.5 * np.pi))
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(
             wire_symbols=('ZZ', 'ZZ'), exponent=self._diagram_exponent(args)
         )
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray | None:
         if protocols.is_parameterized(self):
             return None
 
@@ -342,7 +340,7 @@ class ZZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
 
         return args.target_tensor
 
-    def _phase_by_(self, phase_turns: float, qubit_index: int) -> "ZZPowGate":
+    def _phase_by_(self, phase_turns: float, qubit_index: int) -> ZZPowGate:
         return self
 
     def __str__(self) -> str:
@@ -382,8 +380,8 @@ class MSGate(XXPowGate):
         return type(self)(rads=exponent * np.pi / 2)
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Union[str, 'protocols.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> str | protocols.CircuitDiagramInfo:
         angle_str = self._format_exponent_as_angle(args, order=4)
         symbol = f'MS({angle_str})'
         return protocols.CircuitDiagramInfo(wire_symbols=(symbol, symbol))
@@ -403,11 +401,11 @@ class MSGate(XXPowGate):
     def _json_namespace_(cls) -> str:
         return 'cirq'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ["rads"])
 
     @classmethod
-    def _from_json_dict_(cls, rads: float, **kwargs: Any) -> 'MSGate':
+    def _from_json_dict_(cls, rads: float, **kwargs: Any) -> MSGate:
         return cls(rads=rads)