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

cirq/ops/controlled_gate_test.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from types import NotImplementedType
-from typing import Any, cast, Optional, Sequence, Tuple, Union
+from __future__ import annotations
+
+from types import EllipsisType, NotImplementedType
+from typing import Any, cast, Sequence
 
 import numpy as np
 import pytest
@@ -23,7 +25,7 @@ import cirq
 
 
 class GateUsingWorkspaceForApplyUnitary(cirq.testing.SingleQubitGate):
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         args.available_buffer[...] = args.target_tensor
         args.target_tensor[...] = 0
         return args.available_buffer
@@ -42,10 +44,10 @@ class GateAllocatingNewSpaceForResult(cirq.testing.SingleQubitGate):
     def __init__(self):
         self._matrix = cirq.testing.random_unitary(2, random_state=4321)
 
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         assert len(args.axes) == 1
         a = args.axes[0]
-        seed = cast(Tuple[Union[int, slice, 'ellipsis'], ...], (slice(None),))
+        seed = cast(tuple[int | slice | EllipsisType, ...], (slice(None),))
         zero = seed * a + (0, Ellipsis)
         one = seed * a + (1, Ellipsis)
         result = np.zeros(args.target_tensor.shape, args.target_tensor.dtype)
@@ -110,13 +112,13 @@ C_02_20H = cirq.ControlledGate(
 C2Restricted = cirq.ControlledGate(RestrictedGate(), control_values=[2], control_qid_shape=(3,))
 
 
-def test_init():
+def test_init() -> None:
     gate = cirq.ControlledGate(cirq.Z)
     assert gate.sub_gate is cirq.Z
     assert gate.num_qubits() == 2
 
 
-def test_init2():
+def test_init2() -> None:
     with pytest.raises(ValueError, match=r'cirq\.num_qubits\(control_values\) != num_controls'):
         cirq.ControlledGate(cirq.Z, num_controls=1, control_values=(1, 0))
     with pytest.raises(ValueError, match=r'len\(control_qid_shape\) != num_controls'):
@@ -186,7 +188,7 @@ def test_init2():
     assert cirq.qid_shape(gate) == (3, 3, 2)
 
 
-def test_validate_args():
+def test_validate_args() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -232,7 +234,7 @@ def test_validate_args():
     _ = C2C2H.on(q3, p3, a)
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(CY, cirq.ControlledGate(cirq.Y))
     eq.add_equality_group(CCH)
@@ -270,7 +272,7 @@ def test_eq():
                 np.testing.assert_allclose(cirq.unitary(item), cirq.unitary(group[0]))
 
 
-def test_control():
+def test_control() -> None:
     class G(cirq.testing.SingleQubitGate):
         def _has_mixture_(self):
             return True
@@ -299,7 +301,7 @@ def test_control():
     eq.add_equality_group(
         cirq.ControlledGate(g, num_controls=2),
         g.controlled(control_values=[1, 1]),
-        g.controlled(control_qid_shape=[2, 2]),
+        g.controlled(control_qid_shape=(2, 2)),
         g.controlled(num_controls=2),
         g.controlled().controlled(),
         g.controlled(control_values=cirq.SumOfProducts([[1, 1]])),
@@ -312,14 +314,14 @@ def test_control():
     )
     eq.add_equality_group(g.controlled(control_values=[0]).controlled(control_values=[1]))
     eq.add_equality_group(
-        cirq.ControlledGate(g, control_qid_shape=[4, 3]),
-        g.controlled(control_qid_shape=[4, 3]),
-        g.controlled(control_qid_shape=[3]).controlled(control_qid_shape=[4]),
+        cirq.ControlledGate(g, control_qid_shape=(4, 3)),
+        g.controlled(control_qid_shape=(4, 3)),
+        g.controlled(control_qid_shape=(3,)).controlled(control_qid_shape=(4,)),
     )
-    eq.add_equality_group(g.controlled(control_qid_shape=[4]).controlled(control_qid_shape=[3]))
+    eq.add_equality_group(g.controlled(control_qid_shape=(4,)).controlled(control_qid_shape=(3,)))
 
 
-def test_unitary():
+def test_unitary() -> None:
     cxa = cirq.ControlledGate(cirq.X ** sympy.Symbol('a'))
     assert not cirq.has_unitary(cxa)
     assert cirq.unitary(cxa, None) is None
@@ -424,7 +426,7 @@ def test_unitary():
         (C0C_xorH, False),
     ],
 )
-def test_controlled_gate_is_consistent(gate: cirq.Gate, should_decompose_to_target):
+def test_controlled_gate_is_consistent(gate: cirq.Gate, should_decompose_to_target) -> None:
     _test_controlled_gate_is_consistent(gate, should_decompose_to_target)
 
 
@@ -464,7 +466,7 @@ def test_nontrivial_controlled_gate_is_consistent(
     control_qid_shape: Sequence[int],
     control_values: Any,
     should_decompose_to_target: bool,
-):
+) -> None:
     _test_controlled_gate_is_consistent(
         gate, should_decompose_to_target, control_qid_shape, control_values
     )
@@ -473,7 +475,7 @@ def test_nontrivial_controlled_gate_is_consistent(
 def _test_controlled_gate_is_consistent(
     gate: cirq.Gate,
     should_decompose_to_target: bool,
-    control_qid_shape: Optional[Sequence[int]] = None,
+    control_qid_shape: Sequence[int] | None = None,
     control_values: Any = None,
 ):
     cgate = cirq.ControlledGate(
@@ -494,7 +496,41 @@ def _test_controlled_gate_is_consistent(
         np.testing.assert_allclose(cirq.unitary(cgate), cirq.unitary(circuit), atol=1e-13)
 
 
-def test_pow_inverse():
+@pytest.mark.parametrize(
+    'sub_gate, expected_decomposition',
+    [
+        (cirq.X, [cirq.CX]),
+        (cirq.CX, [cirq.CCX]),
+        (cirq.XPowGate(), [cirq.CXPowGate()]),
+        (cirq.CXPowGate(), [cirq.CCXPowGate()]),
+        (cirq.Z, [cirq.CZ]),
+        (cirq.CZ, [cirq.CCZ]),
+        (cirq.ZPowGate(), [cirq.CZPowGate()]),
+        (cirq.CZPowGate(), [cirq.CCZPowGate()]),
+    ],
+)
+def test_controlled_gate_decomposition_uses_canonical_version(
+    sub_gate: cirq.Gate, expected_decomposition: list[cirq.Gate]
+) -> None:
+    cgate = cirq.ControlledGate(sub_gate, num_controls=1)
+    qubits = cirq.LineQubit.range(1 + sub_gate.num_qubits())
+    dec = cirq.decompose_once(cgate.on(*qubits))
+    assert dec == [gate.on(*qubits) for gate in expected_decomposition]
+
+
+@pytest.mark.parametrize(
+    'sub_gate, expected_decomposition', [(cirq.Z, [cirq.CZ]), (cirq.ZPowGate(), [cirq.CZPowGate()])]
+)
+def test_controlled_gate_full_decomposition(
+    sub_gate: cirq.Gate, expected_decomposition: list[cirq.Gate]
+) -> None:
+    cgate = cirq.ControlledGate(sub_gate, num_controls=1)
+    qubits = cirq.LineQubit.range(1 + sub_gate.num_qubits())
+    dec = cirq.decompose(cgate.on(*qubits))
+    assert dec == [gate.on(*qubits) for gate in expected_decomposition]
+
+
+def test_pow_inverse() -> None:
     assert cirq.inverse(CRestricted, None) is None
     assert cirq.pow(CRestricted, 1.5, None) is None
     assert cirq.pow(CY, 1.5) == cirq.ControlledGate(cirq.Y**1.5)
@@ -513,7 +549,7 @@ def test_pow_inverse():
     assert cirq.inverse(C2Y) == C2Y**-1 == C2Y
 
 
-def test_extrapolatable_effect():
+def test_extrapolatable_effect() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -524,7 +560,7 @@ def test_extrapolatable_effect():
     assert cirq.ControlledGate(cirq.Z) ** 0.5 == cirq.ControlledGate(cirq.Z**0.5)
 
 
-def test_reversible():
+def test_reversible() -> None:
     assert cirq.inverse(cirq.ControlledGate(cirq.S)) == cirq.ControlledGate(cirq.S**-1)
     assert cirq.inverse(cirq.ControlledGate(cirq.S, num_controls=4)) == cirq.ControlledGate(
         cirq.S**-1, num_controls=4
@@ -542,7 +578,7 @@ class UnphaseableGate(cirq.Gate):
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_parameterizable(resolve_fn):
+def test_parameterizable(resolve_fn) -> None:
     a = sympy.Symbol('a')
     cy = cirq.ControlledGate(cirq.Y)
     cya = cirq.ControlledGate(cirq.YPowGate(exponent=a))
@@ -557,7 +593,7 @@ def test_parameterizable(resolve_fn):
         resolve_fn(cchan, cirq.ParamResolver({'a': 0.1}))
 
 
-def test_circuit_diagram_info():
+def test_circuit_diagram_info() -> None:
     assert cirq.circuit_diagram_info(CY) == cirq.CircuitDiagramInfo(
         wire_symbols=('@', 'Y'), exponent=1
     )
@@ -609,7 +645,7 @@ class MultiH(cirq.Gate):
         return True
 
 
-def test_circuit_diagram_product_of_sums():
+def test_circuit_diagram_product_of_sums() -> None:
     qubits = cirq.LineQubit.range(3)
     c = cirq.Circuit()
     c.append(cirq.ControlledGate(MultiH(2))(*qubits))
@@ -625,9 +661,9 @@ def test_circuit_diagram_product_of_sums():
 """,
     )
 
-    qubits = cirq.LineQid.for_qid_shape((3, 3, 3, 2))
+    qids = cirq.LineQid.for_qid_shape((3, 3, 3, 2))
     c = cirq.Circuit(
-        MultiH(1)(*qubits[3:]).controlled_by(*qubits[:3], control_values=[1, (0, 1), (2, 0)])
+        MultiH(1)(*qids[3:]).controlled_by(*qids[:3], control_values=[1, (0, 1), (2, 0)])
     )
 
     cirq.testing.assert_has_diagram(
@@ -644,7 +680,7 @@ def test_circuit_diagram_product_of_sums():
     )
 
 
-def test_circuit_diagram_sum_of_products():
+def test_circuit_diagram_sum_of_products() -> None:
     q = cirq.LineQubit.range(4)
     c = cirq.Circuit(C_xorH.on(*q[:3]), C_01_10_11H.on(*q[:3]), C0C_xorH.on(*q))
     cirq.testing.assert_has_diagram(
@@ -659,8 +695,8 @@ def test_circuit_diagram_sum_of_products():
 3: ─────────────────────H───────
 """,
     )
-    q = cirq.LineQid.for_qid_shape((2, 3, 2))
-    c = cirq.Circuit(C_02_20H(*q))
+    qid = cirq.LineQid.for_qid_shape((2, 3, 2))
+    c = cirq.Circuit(C_02_20H(*qid))
     cirq.testing.assert_has_diagram(
         c,
         """
@@ -682,7 +718,7 @@ class MockGate(cirq.testing.TwoQubitGate):
         return True
 
 
-def test_uninformed_circuit_diagram_info():
+def test_uninformed_circuit_diagram_info() -> None:
     qbits = cirq.LineQubit.range(3)
     mock_gate = MockGate()
     cgate = cirq.ControlledGate(mock_gate)(*qbits)
@@ -695,7 +731,7 @@ def test_uninformed_circuit_diagram_info():
     assert mock_gate.captured_diagram_args == args
 
 
-def test_bounded_effect():
+def test_bounded_effect() -> None:
     assert cirq.trace_distance_bound(CY**0.001) < 0.01
     assert cirq.approx_eq(cirq.trace_distance_bound(CCH), 1.0)
     foo = sympy.Symbol('foo')
@@ -715,11 +751,11 @@ def test_bounded_effect():
         C_02_20H,
     ],
 )
-def test_repr(gate):
+def test_repr(gate) -> None:
     cirq.testing.assert_equivalent_repr(gate)
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.ControlledGate(cirq.X)) == 'CX'
     assert str(cirq.ControlledGate(cirq.Z)) == 'CZ'
     assert str(cirq.ControlledGate(cirq.S)) == 'CS'
@@ -733,7 +769,66 @@ def test_str():
     assert str(C2Restricted) == 'C2Restricted'
 
 
-def test_controlled_mixture():
+def test_controlled_mixture() -> None:
     c_yes = cirq.ControlledGate(sub_gate=cirq.phase_flip(0.25), num_controls=1)
     assert cirq.has_mixture(c_yes)
     assert cirq.approx_eq(cirq.mixture(c_yes), [(0.75, np.eye(4)), (0.25, cirq.unitary(cirq.CZ))])
+
+
+@pytest.mark.parametrize(
+    'num_controls, angle, control_values',
+    [
+        (1, np.pi / 4, ((1,),)),
+        (3, -np.pi / 2, ((1,), (1,), (1,))),
+        (2, 0.0, ((1,), (1,))),
+        (2, np.pi / 5, ((0,), (0,))),
+        (3, np.pi, ((1,), (0,), (1,))),
+        (4, -np.pi / 3, ((0,), (1,), (1,), (0,))),
+    ],
+)
+def test_controlled_global_phase_matrix_gate_decomposes(
+    num_controls, angle, control_values
+) -> None:
+    all_qubits = cirq.LineQubit.range(num_controls)
+    control_values = cirq.ops.control_values.ProductOfSums(control_values)
+    control_qid_shape = (2,) * num_controls
+    phase_value = np.exp(1j * angle)
+
+    cg_matrix = cirq.ControlledGate(
+        sub_gate=cirq.MatrixGate(np.array([[phase_value]])),
+        num_controls=num_controls,
+        control_values=control_values,
+        control_qid_shape=control_qid_shape,
+    )
+
+    decomposed = cirq.decompose(cg_matrix(*all_qubits))
+    assert not any(isinstance(op.gate, cirq.MatrixGate) for op in decomposed)
+    np.testing.assert_allclose(cirq.unitary(cirq.Circuit(decomposed)), cirq.unitary(cg_matrix))
+
+
+@pytest.mark.parametrize('gate_type', [cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZPowGate])
+@pytest.mark.parametrize('test_shift', np.pi * (np.random.default_rng(324).random(10) * 2 - 1))
+def test_controlled_phase_extracted_before_decomposition(gate_type, test_shift) -> None:
+    test_shift = 0.123  # arbitrary
+
+    shifted_gate = gate_type(global_shift=test_shift).controlled()
+    unshifted_gate = gate_type().controlled()
+    qs = cirq.LineQubit.range(cirq.num_qubits(shifted_gate))
+    shifted_op = shifted_gate.on(*qs)
+    unshifted_op = unshifted_gate.on(*qs)
+    shifted_decomposition = cirq.decompose(shifted_op)
+    unshifted_decomposition = cirq.decompose(unshifted_op)
+
+    # No brute-force calculation. It's the standard decomposition plus Z for the controlled shift.
+    assert shifted_decomposition[:-1] == unshifted_decomposition
+    z_op = shifted_decomposition[-1]
+    assert z_op.qubits == (qs[0],)
+    z = z_op.gate
+    assert isinstance(z, cirq.ZPowGate)
+    np.testing.assert_approx_equal(z.exponent, test_shift)
+    assert z.global_shift == 0
+
+    # Sanity check that the decomposition is equivalent
+    np.testing.assert_allclose(
+        cirq.unitary(cirq.Circuit(shifted_decomposition)), cirq.unitary(shifted_op), atol=1e-10
+    )

cirq/ops/controlled_operation.py

@@ -12,19 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from types import NotImplementedType
-from typing import (
-    AbstractSet,
-    Any,
-    Collection,
-    Dict,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from __future__ import annotations
+
+from types import EllipsisType, NotImplementedType
+from typing import AbstractSet, Any, Collection, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -53,11 +44,9 @@ class ControlledOperation(raw_types.Operation):
 
     def __init__(
         self,
-        controls: Sequence['cirq.Qid'],
-        sub_operation: 'cirq.Operation',
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
+        controls: Sequence[cirq.Qid],
+        sub_operation: cirq.Operation,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
     ):
         """Initializes the controlled operation.
 
@@ -114,7 +103,7 @@ class ControlledOperation(raw_types.Operation):
             self._control_values = self._control_values & sub_operation.control_values
 
     @property
-    def controls(self) -> Tuple['cirq.Qid', ...]:
+    def controls(self) -> tuple[cirq.Qid, ...]:
         return self._controls
 
     @property
@@ -122,11 +111,11 @@ class ControlledOperation(raw_types.Operation):
         return self._control_values
 
     @property
-    def sub_operation(self) -> 'cirq.Operation':
+    def sub_operation(self) -> cirq.Operation:
         return self._sub_operation
 
     @property
-    def gate(self) -> Optional['cirq.ControlledGate']:
+    def gate(self) -> cirq.ControlledGate | None:
         if self.sub_operation.gate is None:
             return None
         return controlled_gate.ControlledGate(
@@ -148,7 +137,7 @@ class ControlledOperation(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_with_qubits(
             self.gate, self.qubits, NotImplemented, flatten=False, context=context
         )
@@ -176,12 +165,12 @@ class ControlledOperation(raw_types.Operation):
         )
         return sorted_controls, tuple(expanded_cvals), self.sub_operation
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> np.ndarray:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray:
         n = len(self.controls)
         sub_n = len(args.axes) - n
         sub_axes = args.axes[n:]
         for control_vals in self.control_values.expand():
-            active: Tuple[Union['ellipsis', slice], ...] = (
+            active: tuple[EllipsisType | slice, ...] = (
                 ...,
                 *(slice(v, v + 1) for v in control_vals),
                 *(slice(None),) * sub_n,
@@ -207,7 +196,7 @@ class ControlledOperation(raw_types.Operation):
     def _has_unitary_(self) -> bool:
         return protocols.has_unitary(self.sub_operation)
 
-    def _qasm_(self, args: 'cirq.QasmArgs') -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs) -> str | None:
         if (
             hasattr(self._sub_operation, "gate")
             and len(self._controls) == 1
@@ -241,10 +230,10 @@ class ControlledOperation(raw_types.Operation):
         sub_tensor = sub_matrix.reshape(qid_shape[len(self.controls) :] * 2)
         for control_vals in self.control_values.expand():
             active = (*(v for v in control_vals), *(slice(None),) * sub_n) * 2
-            tensor[active] = sub_tensor
+            tensor[active] = sub_tensor  # type: ignore[index]
         return tensor.reshape((np.prod(qid_shape, dtype=np.int64).item(),) * 2)
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         sub_matrix = protocols.unitary(self.sub_operation, None)
         if sub_matrix is None:
             return NotImplemented
@@ -253,7 +242,7 @@ class ControlledOperation(raw_types.Operation):
     def _has_mixture_(self) -> bool:
         return protocols.has_mixture(self.sub_operation)
 
-    def _mixture_(self) -> Optional[List[Tuple[float, np.ndarray]]]:
+    def _mixture_(self) -> list[tuple[float, np.ndarray]] | None:
         sub_mixture = protocols.mixture(self.sub_operation, None)
         if sub_mixture is None:
             return None
@@ -287,12 +276,12 @@ class ControlledOperation(raw_types.Operation):
         return protocols.parameter_names(self.sub_operation)
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'ControlledOperation':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> ControlledOperation:
         new_sub_op = protocols.resolve_parameters(self.sub_operation, resolver, recursive)
         return ControlledOperation(self.controls, new_sub_op, self.control_values)
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if self._is_parameterized_():
             return None
         u = protocols.unitary(self.sub_operation, default=None)
@@ -301,15 +290,15 @@ class ControlledOperation(raw_types.Operation):
         angle_list = np.append(np.angle(np.linalg.eigvals(u)), 0)
         return protocols.trace_distance_from_angle_list(angle_list)
 
-    def __pow__(self, exponent: Any) -> 'ControlledOperation':
+    def __pow__(self, exponent: Any) -> ControlledOperation:
         new_sub_op = protocols.pow(self.sub_operation, exponent, NotImplemented)
         if new_sub_op is NotImplemented:
             return NotImplemented
         return ControlledOperation(self.controls, new_sub_op, self.control_values)
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Optional['protocols.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> protocols.CircuitDiagramInfo | None:
         n = len(self.controls)
 
         sub_args = protocols.CircuitDiagramInfoArgs(
@@ -344,7 +333,7 @@ class ControlledOperation(raw_types.Operation):
             exponent_qubit_index=exponent_qubit_index,
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'controls': self.controls,
             'control_values': self.control_values,

cirq/ops/controlled_operation_test.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 import re
-from types import NotImplementedType
-from typing import cast, Tuple, Union
+from types import EllipsisType, NotImplementedType
+from typing import cast
 
 import numpy as np
 import pytest
@@ -26,7 +28,7 @@ from cirq import protocols
 
 
 class GateUsingWorkspaceForApplyUnitary(cirq.testing.SingleQubitGate):
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         args.available_buffer[...] = args.target_tensor
         args.target_tensor[...] = 0
         return args.available_buffer
@@ -45,10 +47,10 @@ class GateAllocatingNewSpaceForResult(cirq.testing.SingleQubitGate):
     def __init__(self):
         self._matrix = cirq.testing.random_unitary(2, random_state=1234)
 
-    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Union[np.ndarray, NotImplementedType]:
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray | NotImplementedType:
         assert len(args.axes) == 1
         a = args.axes[0]
-        seed = cast(Tuple[Union[int, slice, 'ellipsis'], ...], (slice(None),))
+        seed = cast(tuple[int | slice | EllipsisType, ...], (slice(None),))
         zero = seed * a + (0, Ellipsis)
         one = seed * a + (1, Ellipsis)
         result = np.zeros(args.target_tensor.shape, args.target_tensor.dtype)
@@ -155,7 +157,7 @@ def test_str():
 
     class SingleQubitOp(cirq.Operation):
         @property
-        def qubits(self) -> Tuple[cirq.Qid, ...]:
+        def qubits(self) -> tuple[cirq.Qid, ...]:
             return ()
 
         def with_qubits(self, *new_qubits: cirq.Qid):