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

cirq/ops/control_values.py

@@ -11,10 +11,13 @@
 # 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
+
 import abc
 import itertools
 from functools import cached_property
-from typing import Any, Collection, Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, Collection, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import protocols, value
 
@@ -47,7 +50,7 @@ class AbstractControlValues(abc.ABC):
         """Validates that all control values for ith qubit are in range [0, qid_shaped[i])"""
 
     @abc.abstractmethod
-    def expand(self) -> 'SumOfProducts':
+    def expand(self) -> SumOfProducts:
         """Returns an expanded `cirq.SumOfProduct` representation of this control values."""
 
     @property
@@ -64,17 +67,15 @@ class AbstractControlValues(abc.ABC):
         """Returns the number of qubits for which control values are stored by this object."""
 
     @abc.abstractmethod
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         """Returns a dictionary used for serializing this object."""
 
     @abc.abstractmethod
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         """Returns information used to draw this object in circuit diagrams."""
 
     @abc.abstractmethod
-    def __iter__(self) -> Iterator[Tuple[int, ...]]:
+    def __iter__(self) -> Iterator[tuple[int, ...]]:
         """Iterator on internal representation of control values used by the derived classes.
 
         Note: Be careful that the terms iterated upon by this iterator will have different
@@ -88,7 +89,7 @@ class AbstractControlValues(abc.ABC):
     def _value_equality_values_(self) -> Any:
         return tuple(v for v in self.expand())
 
-    def __and__(self, other: 'AbstractControlValues') -> 'AbstractControlValues':
+    def __and__(self, other: AbstractControlValues) -> AbstractControlValues:
         """Returns a cartesian product of all control values predicates in `self` x `other`.
 
         The `and` of two control values `cv1` and `cv2` represents a control value object
@@ -109,7 +110,7 @@ class AbstractControlValues(abc.ABC):
             tuple(x + y for (x, y) in itertools.product(self.expand(), other.expand()))
         )
 
-    def __or__(self, other: 'AbstractControlValues') -> 'AbstractControlValues':
+    def __or__(self, other: AbstractControlValues) -> AbstractControlValues:
         """Returns a union of all control values predicates in `self` + `other`.
 
         Both `self` and `other` must represent control values for the same set of qubits and
@@ -140,8 +141,8 @@ class AbstractControlValues(abc.ABC):
 class ProductOfSums(AbstractControlValues):
     """Represents control values as N OR (sum) clauses, each of which applies to one qubit."""
 
-    def __init__(self, data: Sequence[Union[int, Collection[int]]]):
-        self._qubit_sums: Tuple[Tuple[int, ...], ...] = tuple(
+    def __init__(self, data: Sequence[int | Collection[int]]):
+        self._qubit_sums: tuple[tuple[int, ...], ...] = tuple(
             (cv,) if isinstance(cv, int) else tuple(sorted(set(cv))) for cv in data
         )
 
@@ -149,10 +150,10 @@ class ProductOfSums(AbstractControlValues):
     def is_trivial(self) -> bool:
         return self._qubit_sums == ((1,),) * self._num_qubits_()
 
-    def __iter__(self) -> Iterator[Tuple[int, ...]]:
+    def __iter__(self) -> Iterator[tuple[int, ...]]:
         return iter(self._qubit_sums)
 
-    def expand(self) -> 'SumOfProducts':
+    def expand(self) -> SumOfProducts:
         return SumOfProducts(tuple(itertools.product(*self._qubit_sums)))
 
     def __repr__(self) -> str:
@@ -161,7 +162,7 @@ class ProductOfSums(AbstractControlValues):
     def _num_qubits_(self) -> int:
         return len(self._qubit_sums)
 
-    def __getitem__(self, key: Union[int, slice]) -> Union['ProductOfSums', Tuple[int, ...]]:
+    def __getitem__(self, key: int | slice) -> ProductOfSums | tuple[int, ...]:
         if isinstance(key, slice):
             return ProductOfSums(self._qubit_sums[key])
         return self._qubit_sums[key]
@@ -175,9 +176,7 @@ class ProductOfSums(AbstractControlValues):
                 )
                 raise ValueError(message)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         """Returns a string representation to be used in circuit diagrams."""
 
         def get_symbol(vals):
@@ -195,7 +194,7 @@ class ProductOfSums(AbstractControlValues):
 
         return ''.join(get_prefix(t) for t in self._qubit_sums)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {"data": self._qubit_sums}
 
     def __and__(self, other: AbstractControlValues) -> AbstractControlValues:
@@ -242,8 +241,8 @@ class SumOfProducts(AbstractControlValues):
         >>> nand_cop = cirq.X(q2).controlled_by(q0, q1, control_values=nand_control_values)
     """
 
-    def __init__(self, data: Collection[Sequence[int]], *, name: Optional[str] = None):
-        self._conjunctions: Tuple[Tuple[int, ...], ...] = tuple(
+    def __init__(self, data: Collection[Sequence[int]], *, name: str | None = None):
+        self._conjunctions: tuple[tuple[int, ...], ...] = tuple(
             sorted(set(tuple(cv) for cv in data))
         )
         self._name = name
@@ -257,16 +256,14 @@ class SumOfProducts(AbstractControlValues):
     def is_trivial(self) -> bool:
         return self._conjunctions == ((1,) * self._num_qubits_(),)
 
-    def expand(self) -> 'SumOfProducts':
+    def expand(self) -> SumOfProducts:
         return self
 
-    def __iter__(self) -> Iterator[Tuple[int, ...]]:
+    def __iter__(self) -> Iterator[tuple[int, ...]]:
         """Returns the combinations tracked by the object."""
         return iter(self._conjunctions)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         """Returns a string representation to be used in circuit diagrams."""
         if self._name is not None:
             wire_symbols = ['@'] * self._num_qubits_()
@@ -316,5 +313,5 @@ class SumOfProducts(AbstractControlValues):
                         f' of range [0, {qid_shapes[q_i]}) for control qubit number <{q_i}>.'
                     )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'data': self._conjunctions, 'name': self._name}

cirq/ops/control_values_test.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq
 
 
-def test_init_sum_of_products_raises():
+def test_init_sum_of_products_raises() -> None:
     # data shouldn't be empty.
     with pytest.raises(ValueError):
         _ = cirq.SumOfProducts([])
@@ -27,7 +29,7 @@ def test_init_sum_of_products_raises():
         _ = cirq.SumOfProducts([[1], [1, 0]])
 
 
-def test_init_product_of_sums():
+def test_init_product_of_sums() -> None:
     eq = cirq.testing.EqualsTester()
     # 0. Trivial case of 1 control and 1 qubit.
     eq.add_equality_group(cirq.ProductOfSums([1]), cirq.ProductOfSums(((1,),)))
@@ -57,7 +59,7 @@ def test_init_product_of_sums():
     eq.add_equality_group([(1, 2), (0, 1)])
 
 
-def test_init_sum_of_products():
+def test_init_sum_of_products() -> None:
     eq = cirq.testing.EqualsTester()
     # 0. Trivial case of 1 control and 1 qubit
     eq.add_equality_group(cirq.SumOfProducts([[1]]), cirq.SumOfProducts(((1,),)))
@@ -88,7 +90,7 @@ def test_init_sum_of_products():
     eq.add_equality_group(cirq.SumOfProducts([(1, 0), (2, 0), (1, 1), (2, 1)]))
 
 
-def test_equality_across_types():
+def test_equality_across_types() -> None:
     eq = cirq.testing.EqualsTester()
     # Trivial case of 1 control and 1 qubit
     eq.add_equality_group(
@@ -122,7 +124,7 @@ def test_equality_across_types():
     eq.add_equality_group(cirq.ProductOfSums([(0, 1), (1, 0)]))  # or control
 
 
-def test_and_operation():
+def test_and_operation() -> None:
     eq = cirq.testing.EqualsTester()
 
     eq.add_equality_group(
@@ -169,12 +171,12 @@ def test_and_operation():
         [cirq.SumOfProducts([(0, 0), (1, 1)]), cirq.ProductOfSums([0, 1, 2]), cirq.SumOfProducts],
     ],
 )
-def test_and_operation_adds_qubits(cv1, cv2, expected_type):
+def test_and_operation_adds_qubits(cv1, cv2, expected_type) -> None:
     assert isinstance(cv1 & cv2, expected_type)
     assert cirq.num_qubits(cv1 & cv2) == cirq.num_qubits(cv1) + cirq.num_qubits(cv2)
 
 
-def test_or_operation():
+def test_or_operation() -> None:
     eq = cirq.testing.EqualsTester()
 
     eq.add_equality_group(
@@ -212,7 +214,7 @@ def test_or_operation():
         [cirq.SumOfProducts([[0], [1], [2]]), cirq.SumOfProducts([[1, 0]]), None],
     ],
 )
-def test_or_operation_acts_on_same_qubits(cv1, cv2, expected_type):
+def test_or_operation_acts_on_same_qubits(cv1, cv2, expected_type) -> None:
     if cirq.num_qubits(cv1) == cirq.num_qubits(cv2):
         assert cirq.num_qubits(cv1 | cv2) == cirq.num_qubits(cv1)
         assert expected_type is not None
@@ -224,31 +226,31 @@ def test_or_operation_acts_on_same_qubits(cv1, cv2, expected_type):
 
 
 @pytest.mark.parametrize('data', [((1,),), ((0, 1), (1,)), [(0, 1), (1, 0)]])
-def test_product_of_sums_repr(data):
+def test_product_of_sums_repr(data) -> None:
     cirq.testing.assert_equivalent_repr(cirq.ProductOfSums(data))
 
 
 @pytest.mark.parametrize('data', [((1,),), ((0, 1),), ((0, 0), (0, 1), (1, 0))])
-def test_sum_of_products_repr(data):
+def test_sum_of_products_repr(data) -> None:
     cirq.testing.assert_equivalent_repr(cirq.SumOfProducts(data))
     cirq.testing.assert_equivalent_repr(cirq.SumOfProducts(data, name="CustomName"))
 
 
-def test_sum_of_products_validate():
+def test_sum_of_products_validate() -> None:
     control_val = cirq.SumOfProducts(((1, 2), (0, 1)))
 
-    _ = control_val.validate([2, 3])
+    control_val.validate([2, 3])
 
     with pytest.raises(ValueError):
-        _ = control_val.validate([2, 2])
+        control_val.validate([2, 2])
 
     # number of qubits != number of control values.
     with pytest.raises(ValueError):
-        _ = control_val.validate([2])
+        control_val.validate([2])
 
 
 @pytest.mark.parametrize('data', [((1,),), ((0, 1),), ((0, 0), (0, 1), (1, 0))])
-def test_sum_of_products_num_qubits(data):
+def test_sum_of_products_num_qubits(data) -> None:
     assert cirq.num_qubits(cirq.SumOfProducts(data)) == len(data[0])
 
 
@@ -261,7 +263,7 @@ def test_sum_of_products_num_qubits(data):
         [((1, 1, 1, 1),), True],
     ],
 )
-def test_sum_of_products_is_trivial(data, is_trivial):
+def test_sum_of_products_is_trivial(data, is_trivial) -> None:
     assert cirq.SumOfProducts(data).is_trivial == is_trivial
 
 
@@ -269,16 +271,16 @@ def test_sum_of_products_is_trivial(data, is_trivial):
     'data, is_trivial',
     [[((1,),), True], [((0, 1),), False], [([2], [1], [2]), False], [([1], [1], [1], [1]), True]],
 )
-def test_product_of_sum_is_trivial(data, is_trivial):
+def test_product_of_sum_is_trivial(data, is_trivial) -> None:
     assert cirq.ProductOfSums(data).is_trivial == is_trivial
 
 
-def test_product_of_sums_str():
+def test_product_of_sums_str() -> None:
     c = cirq.ProductOfSums([(0, 1), 1, 0, (0, 2)])
     assert str(c) == 'C01C1C0C02'
 
 
-def test_sum_of_products_str():
+def test_sum_of_products_str() -> None:
     c = cirq.SumOfProducts(((1, 0), (0, 1)))
     assert str(c) == 'C_01_10'
 
@@ -286,7 +288,7 @@ def test_sum_of_products_str():
     assert str(c) == 'C_xor'
 
 
-def test_control_values_diagrams():
+def test_control_values_diagrams() -> None:
     q = cirq.LineQubit.range(3)
     ccx = cirq.X(q[0]).controlled_by(*q[1:])
     ccx_sop = cirq.X(q[0]).controlled_by(*q[1:], control_values=cirq.SumOfProducts([[1, 1]]))

cirq/ops/controlled_gate.py

@@ -12,19 +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,
-    Collection,
-    Dict,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import AbstractSet, Any, Collection, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -33,7 +24,6 @@ from cirq.ops import (
     control_values as cv,
     controlled_operation as cop,
     diagonal_gate as dg,
-    global_phase_op as gp,
     op_tree,
     raw_types,
 )
@@ -57,12 +47,10 @@ class ControlledGate(raw_types.Gate):
 
     def __init__(
         self,
-        sub_gate: 'cirq.Gate',
-        num_controls: Optional[int] = None,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
-        control_qid_shape: Optional[Sequence[int]] = None,
+        sub_gate: cirq.Gate,
+        num_controls: int | None = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
+        control_qid_shape: Sequence[int] | None = None,
     ) -> None:
         """Initializes the controlled gate. If no arguments are specified for
            the controls, defaults to a single qubit control.
@@ -133,7 +121,7 @@ class ControlledGate(raw_types.Gate):
             self._sub_gate = sub_gate
 
     @property
-    def control_qid_shape(self) -> Tuple[int, ...]:
+    def control_qid_shape(self) -> tuple[int, ...]:
         return self._control_qid_shape
 
     @property
@@ -141,102 +129,70 @@ class ControlledGate(raw_types.Gate):
         return self._control_values
 
     @property
-    def sub_gate(self) -> 'cirq.Gate':
+    def sub_gate(self) -> cirq.Gate:
         return self._sub_gate
 
     def num_controls(self) -> int:
         return len(self.control_qid_shape)
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return self.control_qid_shape + protocols.qid_shape(self.sub_gate)
 
-    def _decompose_(
-        self, qubits: Tuple['cirq.Qid', ...]
-    ) -> Union[None, NotImplementedType, 'cirq.OP_TREE']:
-        return self._decompose_with_context_(qubits)
-
     def _decompose_with_context_(
-        self, qubits: Tuple['cirq.Qid', ...], context: Optional['cirq.DecompositionContext'] = None
-    ) -> Union[None, NotImplementedType, 'cirq.OP_TREE']:
+        self, qubits: tuple[cirq.Qid, ...], context: cirq.DecompositionContext
+    ) -> NotImplementedType | cirq.OP_TREE:
         control_qubits = list(qubits[: self.num_controls()])
-        if (
-            protocols.has_unitary(self.sub_gate)
-            and protocols.num_qubits(self.sub_gate) == 1
-            and self._qid_shape_() == (2,) * len(self._qid_shape_())
-            and isinstance(self.control_values, cv.ProductOfSums)
-        ):
-            invert_ops: List['cirq.Operation'] = []
-            for cvals, cqbit in zip(self.control_values, qubits[: self.num_controls()]):
-                if set(cvals) == {0}:
-                    invert_ops.append(common_gates.X(cqbit))
-                elif set(cvals) == {0, 1}:
-                    control_qubits.remove(cqbit)
-            decomposed_ops = controlled_gate_decomposition.decompose_multi_controlled_rotation(
-                protocols.unitary(self.sub_gate), control_qubits, qubits[-1]
-            )
-            return invert_ops + decomposed_ops + invert_ops
-        if isinstance(self.sub_gate, gp.GlobalPhaseGate):
-            # A controlled global phase is a diagonal gate, where each active control value index
-            # is set equal to the phase angle.
-            shape = self.control_qid_shape
-            if protocols.is_parameterized(self.sub_gate) or set(shape) != {2}:
-                # Could work in theory, but DiagonalGate decompose does not support them.
-                return NotImplemented
-            angle = np.angle(complex(self.sub_gate.coefficient))
-            rads = np.zeros(shape=shape)
-            for hot in self.control_values.expand():
-                rads[hot] = angle
-            return dg.DiagonalGate(diag_angles_radians=[*rads.flatten()]).on(*qubits)
-        if isinstance(self.sub_gate, common_gates.CZPowGate):
-            z_sub_gate = common_gates.ZPowGate(exponent=self.sub_gate.exponent)
-            num_controls = self.num_controls() + 1
-            control_values = self.control_values & cv.ProductOfSums(((1,),))
-            control_qid_shape = self.control_qid_shape + (2,)
-            controlled_z = (
-                z_sub_gate.controlled(
-                    num_controls=num_controls,
-                    control_values=control_values,
-                    control_qid_shape=control_qid_shape,
-                )
-                if protocols.is_parameterized(self)
-                else ControlledGate(
-                    z_sub_gate,
-                    num_controls=num_controls,
-                    control_values=control_values,
-                    control_qid_shape=control_qid_shape,
-                )
-            )
-            if self != controlled_z:
-                result = controlled_z.on(*qubits)
-                if self.sub_gate.global_shift == 0:
-                    return result
-                # Reconstruct the controlled global shift of the subgate.
-                total_shift = self.sub_gate.exponent * self.sub_gate.global_shift
-                phase_gate = gp.GlobalPhaseGate(1j ** (2 * total_shift))
-                controlled_phase_op = phase_gate.controlled(
-                    num_controls=self.num_controls(),
-                    control_values=self.control_values,
-                    control_qid_shape=self.control_qid_shape,
-                ).on(*control_qubits)
-                return [result, controlled_phase_op]
+        controlled_sub_gate = self.sub_gate.controlled(
+            self.num_controls(), self.control_values, self.control_qid_shape
+        )
+        # Prefer the subgate controlled version if available
+        if self != controlled_sub_gate:
+            return controlled_sub_gate.on(*qubits)
+
+        # Try decomposing the subgate next.
         result = protocols.decompose_once_with_qubits(
             self.sub_gate,
             qubits[self.num_controls() :],
             NotImplemented,
             flatten=False,
-            context=context,
+            # Extract global phases from decomposition, as controlled phases decompose easily.
+            context=context.extracting_global_phases(),
         )
-        if result is NotImplemented:
-            return NotImplemented
+        if result is not NotImplemented:
+            return op_tree.transform_op_tree(
+                result,
+                lambda op: op.controlled_by(
+                    *qubits[: self.num_controls()], control_values=self.control_values
+                ),
+            )
 
-        return op_tree.transform_op_tree(
-            result,
-            lambda op: op.controlled_by(
-                *qubits[: self.num_controls()], control_values=self.control_values
-            ),
-        )
+        # Finally try brute-force on the unitary.
+        if protocols.has_unitary(self.sub_gate) and all(q.dimension == 2 for q in qubits):
+            n_qubits = protocols.num_qubits(self.sub_gate)
+            # Case 1: Global Phase (1x1 Matrix)
+            if n_qubits == 0:
+                angle = np.angle(protocols.unitary(self.sub_gate)[0, 0])
+                rads = np.zeros(shape=self.control_qid_shape)
+                for hot in self.control_values.expand():
+                    rads[hot] = angle
+                return dg.DiagonalGate(diag_angles_radians=[*rads.flatten()]).on(*qubits)
+            # Case 2: Multi-controlled single-qubit gate decomposition
+            if n_qubits == 1 and isinstance(self.control_values, cv.ProductOfSums):
+                invert_ops: list[cirq.Operation] = []
+                for cvals, cqbit in zip(self.control_values, qubits[: self.num_controls()]):
+                    if set(cvals) == {0}:
+                        invert_ops.append(common_gates.X(cqbit))
+                    elif set(cvals) == {0, 1}:
+                        control_qubits.remove(cqbit)
+                decomposed_ops = controlled_gate_decomposition.decompose_multi_controlled_rotation(
+                    protocols.unitary(self.sub_gate), control_qubits, qubits[-1]
+                )
+                return invert_ops + decomposed_ops + invert_ops
+
+        # If nothing works, return `NotImplemented`.
+        return NotImplemented
 
-    def on(self, *qubits: 'cirq.Qid') -> cop.ControlledOperation:
+    def on(self, *qubits: cirq.Qid) -> cop.ControlledOperation:
         if len(qubits) == 0:
             raise ValueError(f"Applied a gate to an empty set of qubits. Gate: {self!r}")
         self.validate_args(qubits)
@@ -249,7 +205,7 @@ class ControlledGate(raw_types.Gate):
     def _value_equality_values_(self):
         return (self.sub_gate, self.num_controls(), self.control_values, self.control_qid_shape)
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> np.ndarray:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray:
         qubits = line_qubit.LineQid.for_gate(self)
         op = self.sub_gate.on(*qubits[self.num_controls() :])
         c_op = cop.ControlledOperation(qubits[: self.num_controls()], op, self.control_values)
@@ -258,7 +214,7 @@ class ControlledGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return protocols.has_unitary(self.sub_gate)
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         qubits = line_qubit.LineQid.for_gate(self)
         op = self.sub_gate.on(*qubits[self.num_controls() :])
         c_op = cop.ControlledOperation(qubits[: self.num_controls()], op, self.control_values)
@@ -268,13 +224,13 @@ class ControlledGate(raw_types.Gate):
     def _has_mixture_(self) -> bool:
         return protocols.has_mixture(self.sub_gate)
 
-    def _mixture_(self) -> Union[Sequence[tuple[float, np.ndarray]], NotImplementedType]:
+    def _mixture_(self) -> Sequence[tuple[float, np.ndarray]] | NotImplementedType:
         qubits = line_qubit.LineQid.for_gate(self)
         op = self.sub_gate.on(*qubits[self.num_controls() :])
         c_op = cop.ControlledOperation(qubits[: self.num_controls()], op, self.control_values)
         return protocols.mixture(c_op, default=NotImplemented)
 
-    def __pow__(self, exponent: Any) -> 'ControlledGate':
+    def __pow__(self, exponent: Any) -> ControlledGate:
         new_sub_gate = protocols.pow(self.sub_gate, exponent, NotImplemented)
         if new_sub_gate is NotImplemented:
             return NotImplemented
@@ -291,9 +247,7 @@ class ControlledGate(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
-    ) -> 'ControlledGate':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> ControlledGate:
         new_sub_gate = protocols.resolve_parameters(self.sub_gate, resolver, recursive)
         return ControlledGate(
             new_sub_gate,
@@ -302,7 +256,7 @@ class ControlledGate(raw_types.Gate):
             control_qid_shape=self.control_qid_shape,
         )
 
-    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_gate, default=None)
@@ -311,9 +265,7 @@ class ControlledGate(raw_types.Gate):
         angle_list = np.append(np.angle(np.linalg.eigvals(u)), 0)
         return protocols.trace_distance_from_angle_list(angle_list)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         sub_args = protocols.CircuitDiagramInfoArgs(
             known_qubit_count=(
                 args.known_qubit_count - self.num_controls()
@@ -355,7 +307,7 @@ class ControlledGate(raw_types.Gate):
             f'control_qid_shape={self.control_qid_shape!r})'
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'control_values': self.control_values,
             'control_qid_shape': self.control_qid_shape,
@@ -363,7 +315,7 @@ class ControlledGate(raw_types.Gate):
         }
 
 
-def _validate_sub_object(sub_object: Union['cirq.Gate', 'cirq.Operation']):
+def _validate_sub_object(sub_object: cirq.Gate | cirq.Operation):
     if protocols.is_measurement(sub_object):
         raise ValueError(f'Cannot control measurement {sub_object}')
     if not protocols.has_mixture(sub_object) and not protocols.is_parameterized(sub_object):