cirq-core 1.6.0.dev20250416221104__py3-none-any.whl → 1.6.0.dev20250417204649__py3-none-any.whl

cirq/ops/common_gates.py

@@ -25,19 +25,10 @@ Each of these are implemented as EigenGates, which means that they can be
 raised to a power (i.e. cirq.H**0.5). See the definition in EigenGate.
 """
 
+from __future__ import annotations
+
 from types import NotImplementedType
-from typing import (
-    Any,
-    cast,
-    Collection,
-    Dict,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, cast, Collection, Dict, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
 import sympy
@@ -50,9 +41,6 @@ from cirq.ops import control_values as cv, controlled_gate, eigen_gate, gate_fea
 from cirq.ops.measurement_gate import MeasurementGate
 from cirq.ops.swap_gates import ISWAP, ISwapPowGate, SWAP, SwapPowGate
 
-if TYPE_CHECKING:
-    import cirq
-
 assert all(
     [ISWAP, SWAP, ISwapPowGate, SwapPowGate, MeasurementGate]
 ), """
@@ -126,7 +114,7 @@ class XPowGate(eigen_gate.EigenGate):
     def _num_qubits_(self) -> int:
         return 1
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> Optional[np.ndarray]:
         if self._exponent != 1 or self._dimension != 2:
             return NotImplemented
         zero = args.subspace_index(0)
@@ -138,11 +126,11 @@ class XPowGate(eigen_gate.EigenGate):
             args.available_buffer *= p
         return args.available_buffer
 
-    def in_su2(self) -> 'Rx':
+    def in_su2(self) -> Rx:
         """Returns an equal-up-global-phase gate from the group SU2."""
         return Rx(rads=self._exponent * _pi(self._exponent))
 
-    def with_canonical_global_phase(self) -> 'XPowGate':
+    def with_canonical_global_phase(self) -> XPowGate:
         """Returns an equal-up-global-phase standardized form of the gate."""
         return XPowGate(exponent=self._exponent, dimension=self._dimension)
 
@@ -161,7 +149,7 @@ class XPowGate(eigen_gate.EigenGate):
             XPowGate._eigencomponents[self._dimension] = components
         return XPowGate._eigencomponents[self._dimension]
 
-    def _with_exponent(self, exponent: 'cirq.TParamVal') -> 'cirq.XPowGate':
+    def _with_exponent(self, exponent: cirq.TParamVal) -> cirq.XPowGate:
         return XPowGate(
             exponent=exponent, global_shift=self._global_shift, dimension=self._dimension
         )
@@ -266,13 +254,13 @@ class XPowGate(eigen_gate.EigenGate):
         return value.LinearDict({'I': phase * lib.cos(angle), 'X': -1j * phase * lib.sin(angle)})
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Union[str, 'protocols.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> Union[str, protocols.CircuitDiagramInfo]:
         return protocols.CircuitDiagramInfo(
             wire_symbols=('X',), exponent=self._diagram_exponent(args)
         )
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
         args.validate_version('2.0', '3.0')
         if self._global_shift == 0:
             if self._exponent == 1:
@@ -349,12 +337,12 @@ class Rx(XPowGate):
         self._rads = rads
         super().__init__(exponent=rads / _pi(rads), global_shift=-0.5)
 
-    def _with_exponent(self, exponent: value.TParamVal) -> 'Rx':
+    def _with_exponent(self, exponent: value.TParamVal) -> Rx:
         return Rx(rads=exponent * _pi(exponent))
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Union[str, 'protocols.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> Union[str, protocols.CircuitDiagramInfo]:
         angle_str = self._format_exponent_as_angle(args)
         return f'Rx({angle_str})'
 
@@ -366,7 +354,7 @@ class Rx(XPowGate):
     def __repr__(self) -> str:
         return f'cirq.Rx(rads={proper_repr(self._rads)})'
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
         args.validate_version('2.0', '3.0')
         return args.format('rx({0:half_turns}) {1};\n', self._exponent, qubits[0])
 
@@ -374,7 +362,7 @@ class Rx(XPowGate):
         return {'rads': self._rads}
 
     @classmethod
-    def _from_json_dict_(cls, rads, **kwargs) -> 'Rx':
+    def _from_json_dict_(cls, rads, **kwargs) -> Rx:
         return cls(rads=rads)
 
 
@@ -412,7 +400,7 @@ class YPowGate(eigen_gate.EigenGate):
     def _num_qubits_(self) -> int:
         return 1
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> Optional[np.ndarray]:
         if self._exponent != 1:
             return NotImplemented
         zero = args.subspace_index(0)
@@ -424,11 +412,11 @@ class YPowGate(eigen_gate.EigenGate):
             args.available_buffer *= p
         return args.available_buffer
 
-    def in_su2(self) -> 'Ry':
+    def in_su2(self) -> Ry:
         """Returns an equal-up-global-phase gate from the group SU2."""
         return Ry(rads=self._exponent * _pi(self._exponent))
 
-    def with_canonical_global_phase(self) -> 'YPowGate':
+    def with_canonical_global_phase(self) -> YPowGate:
         """Returns an equal-up-global-phase standardized form of the gate."""
         return YPowGate(exponent=self._exponent)
 
@@ -463,13 +451,13 @@ class YPowGate(eigen_gate.EigenGate):
         return value.LinearDict({'I': phase * lib.cos(angle), 'Y': -1j * phase * lib.sin(angle)})
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Union[str, 'protocols.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> Union[str, protocols.CircuitDiagramInfo]:
         return protocols.CircuitDiagramInfo(
             wire_symbols=('Y',), exponent=self._diagram_exponent(args)
         )
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
         args.validate_version('2.0', '3.0')
         if self._exponent == 1 and self.global_shift != -0.5:
             return args.format('y {0};\n', qubits[0])
@@ -534,12 +522,12 @@ class Ry(YPowGate):
         self._rads = rads
         super().__init__(exponent=rads / _pi(rads), global_shift=-0.5)
 
-    def _with_exponent(self, exponent: value.TParamVal) -> 'Ry':
+    def _with_exponent(self, exponent: value.TParamVal) -> Ry:
         return Ry(rads=exponent * _pi(exponent))
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Union[str, 'protocols.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> Union[str, protocols.CircuitDiagramInfo]:
         angle_str = self._format_exponent_as_angle(args)
         return f'Ry({angle_str})'
 
@@ -551,7 +539,7 @@ class Ry(YPowGate):
     def __repr__(self) -> str:
         return f'cirq.Ry(rads={proper_repr(self._rads)})'
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
         args.validate_version('2.0', '3.0')
         return args.format('ry({0:half_turns}) {1};\n', self._exponent, qubits[0])
 
@@ -559,7 +547,7 @@ class Ry(YPowGate):
         return {'rads': self._rads}
 
     @classmethod
-    def _from_json_dict_(cls, rads, **kwargs) -> 'Ry':
+    def _from_json_dict_(cls, rads, **kwargs) -> Ry:
         return cls(rads=rads)
 
 
@@ -624,7 +612,7 @@ class ZPowGate(eigen_gate.EigenGate):
     def _num_qubits_(self) -> int:
         return 1
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> Optional[np.ndarray]:
         if protocols.is_parameterized(self):
             return None
 
@@ -650,11 +638,11 @@ class ZPowGate(eigen_gate.EigenGate):
             return SingleQubitCliffordGate.Z_nsqrt.on(*qubits)
         return NotImplemented  # pragma: no cover
 
-    def in_su2(self) -> 'Rz':
+    def in_su2(self) -> Rz:
         """Returns an equal-up-global-phase gate from the group SU2."""
         return Rz(rads=self._exponent * _pi(self._exponent))
 
-    def with_canonical_global_phase(self) -> 'ZPowGate':
+    def with_canonical_global_phase(self) -> ZPowGate:
         """Returns an equal-up-global-phase standardized form of the gate."""
         return ZPowGate(exponent=self._exponent, dimension=self._dimension)
 
@@ -745,7 +733,7 @@ class ZPowGate(eigen_gate.EigenGate):
             ZPowGate._eigencomponents[self._dimension] = components
         return ZPowGate._eigencomponents[self._dimension]
 
-    def _with_exponent(self, exponent: 'cirq.TParamVal') -> 'cirq.ZPowGate':
+    def _with_exponent(self, exponent: cirq.TParamVal) -> cirq.ZPowGate:
         return ZPowGate(
             exponent=exponent, global_shift=self._global_shift, dimension=self._dimension
         )
@@ -772,8 +760,8 @@ class ZPowGate(eigen_gate.EigenGate):
         return self.exponent % 0.5 == 0
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Union[str, 'protocols.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> Union[str, protocols.CircuitDiagramInfo]:
         e = self._diagram_exponent(args)
         if e in [-0.25, 0.25]:
             return protocols.CircuitDiagramInfo(wire_symbols=('T',), exponent=cast(float, e) * 4)
@@ -783,7 +771,7 @@ class ZPowGate(eigen_gate.EigenGate):
 
         return protocols.CircuitDiagramInfo(wire_symbols=('Z',), exponent=e)
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
         args.validate_version('2.0', '3.0')
 
         if self.global_shift == 0:
@@ -838,7 +826,7 @@ class ZPowGate(eigen_gate.EigenGate):
         return f'cirq.ZPowGate({all_args})'
 
     def _commutes_on_qids_(
-        self, qids: 'Sequence[cirq.Qid]', other: Any, *, atol: float = 1e-8
+        self, qids: Sequence[cirq.Qid], other: Any, *, atol: float = 1e-8
     ) -> Union[bool, NotImplementedType, None]:
         from cirq.ops.parity_gates import ZZPowGate
 
@@ -879,12 +867,12 @@ class Rz(ZPowGate):
         self._rads = rads
         super().__init__(exponent=rads / _pi(rads), global_shift=-0.5)
 
-    def _with_exponent(self, exponent: value.TParamVal) -> 'Rz':
+    def _with_exponent(self, exponent: value.TParamVal) -> Rz:
         return Rz(rads=exponent * _pi(exponent))
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Union[str, 'protocols.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> Union[str, protocols.CircuitDiagramInfo]:
         angle_str = self._format_exponent_as_angle(args)
         return f'Rz({angle_str})'
 
@@ -896,7 +884,7 @@ class Rz(ZPowGate):
     def __repr__(self) -> str:
         return f'cirq.Rz(rads={proper_repr(self._rads)})'
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
         args.validate_version('2.0', '3.0')
         return args.format('rz({0:half_turns}) {1};\n', self._exponent, qubits[0])
 
@@ -904,7 +892,7 @@ class Rz(ZPowGate):
         return {'rads': self._rads}
 
     @classmethod
-    def _from_json_dict_(cls, rads, **kwargs) -> 'Rz':
+    def _from_json_dict_(cls, rads, **kwargs) -> Rz:
         return cls(rads=rads)
 
 
@@ -970,7 +958,7 @@ class HPowGate(eigen_gate.EigenGate):
             return []
         return NotImplemented  # pragma: no cover
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> Optional[np.ndarray]:
         if self._exponent != 1:
             return NotImplemented
 
@@ -995,14 +983,12 @@ class HPowGate(eigen_gate.EigenGate):
         yield XPowGate(exponent=self._exponent, global_shift=self.global_shift).on(q)
         yield YPowGate(exponent=-0.25).on(q)
 
-    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=('H',), exponent=self._diagram_exponent(args)
         )
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
         args.validate_version('2.0', '3.0')
         if self._exponent == 0:
             return args.format('id {0};\n', qubits[0])
@@ -1077,7 +1063,7 @@ class CZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
         return abs(np.sin(self._exponent * 0.5 * np.pi))
 
     def _apply_unitary_(
-        self, args: 'protocols.ApplyUnitaryArgs'
+        self, args: protocols.ApplyUnitaryArgs
     ) -> Union[np.ndarray, NotImplementedType]:
         if protocols.is_parameterized(self):
             return NotImplemented
@@ -1181,14 +1167,12 @@ class CZPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
             )
         return result
 
-    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=('@', '@'), exponent=self._diagram_exponent(args)
         )
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
         if self._exponent != 1:
             return None  # Don't have an equivalent gate in QASM
         args.validate_version('2.0', '3.0')
@@ -1280,14 +1264,12 @@ class CXPowGate(eigen_gate.EigenGate):
             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=('@', 'X'), exponent=self._diagram_exponent(args), exponent_qubit_index=1
         )
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> Optional[np.ndarray]:
         if self._exponent != 1:
             return NotImplemented
 
@@ -1389,7 +1371,7 @@ class CXPowGate(eigen_gate.EigenGate):
             )
         return result
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
         if self._exponent != 1:
             return None  # Don't have an equivalent gate in QASM
         args.validate_version('2.0', '3.0')
@@ -1544,7 +1526,7 @@ document(
 
 def _phased_x_or_pauli_gate(
     exponent: Union[float, sympy.Expr], phase_exponent: Union[float, sympy.Expr]
-) -> Union['cirq.PhasedXPowGate', 'cirq.XPowGate', 'cirq.YPowGate']:
+) -> Union[cirq.PhasedXPowGate, cirq.XPowGate, cirq.YPowGate]:
     """Return PhasedXPowGate or X or Y gate if equivalent at the given phase_exponent."""
     if not isinstance(phase_exponent, sympy.Expr) or phase_exponent.is_constant():
         half_turns = value.canonicalize_half_turns(float(phase_exponent))

cirq/ops/control_values.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
+
 import abc
 import itertools
 from functools import cached_property
@@ -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
@@ -68,9 +71,7 @@ class AbstractControlValues(abc.ABC):
         """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
@@ -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
@@ -152,7 +153,7 @@ class ProductOfSums(AbstractControlValues):
     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: Union[int, slice]) -> Union[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):
@@ -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, ...]]:
         """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_()

cirq/ops/controlled_gate.py

@@ -12,6 +12,8 @@
 # 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,
@@ -57,7 +59,7 @@ class ControlledGate(raw_types.Gate):
 
     def __init__(
         self,
-        sub_gate: 'cirq.Gate',
+        sub_gate: cirq.Gate,
         num_controls: Optional[int] = None,
         control_values: Optional[
             Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
@@ -141,7 +143,7 @@ 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:
@@ -151,13 +153,13 @@ class ControlledGate(raw_types.Gate):
         return self.control_qid_shape + protocols.qid_shape(self.sub_gate)
 
     def _decompose_(
-        self, qubits: Tuple['cirq.Qid', ...]
-    ) -> Union[None, NotImplementedType, 'cirq.OP_TREE']:
+        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: Optional[cirq.DecompositionContext] = None
+    ) -> Union[None, NotImplementedType, cirq.OP_TREE]:
         control_qubits = list(qubits[: self.num_controls()])
         if (
             protocols.has_unitary(self.sub_gate)
@@ -165,7 +167,7 @@ class ControlledGate(raw_types.Gate):
             and self._qid_shape_() == (2,) * len(self._qid_shape_())
             and isinstance(self.control_values, cv.ProductOfSums)
         ):
-            invert_ops: List['cirq.Operation'] = []
+            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))
@@ -236,7 +238,7 @@ class ControlledGate(raw_types.Gate):
             ),
         )
 
-    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 +251,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)
@@ -274,7 +276,7 @@ class ControlledGate(raw_types.Gate):
         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 +293,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,
@@ -311,9 +311,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()
@@ -363,7 +361,7 @@ class ControlledGate(raw_types.Gate):
         }
 
 
-def _validate_sub_object(sub_object: Union['cirq.Gate', 'cirq.Operation']):
+def _validate_sub_object(sub_object: Union[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):

cirq/ops/controlled_operation.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from types import NotImplementedType
+from __future__ import annotations
+
+from types import EllipsisType, NotImplementedType
 from typing import (
     AbstractSet,
     Any,
@@ -53,8 +55,8 @@ class ControlledOperation(raw_types.Operation):
 
     def __init__(
         self,
-        controls: Sequence['cirq.Qid'],
-        sub_operation: 'cirq.Operation',
+        controls: Sequence[cirq.Qid],
+        sub_operation: cirq.Operation,
         control_values: Optional[
             Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
         ] = None,
@@ -114,7 +116,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 +124,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) -> Optional[cirq.ControlledGate]:
         if self.sub_operation.gate is None:
             return None
         return controlled_gate.ControlledGate(
@@ -148,7 +150,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: Optional[cirq.DecompositionContext] = None):
         result = protocols.decompose_once_with_qubits(
             self.gate, self.qubits, NotImplemented, flatten=False, context=context
         )
@@ -176,12 +178,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[Union[EllipsisType, slice], ...] = (
                 ...,
                 *(slice(v, v + 1) for v in control_vals),
                 *(slice(None),) * sub_n,
@@ -207,7 +209,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) -> Optional[str]:
         if (
             hasattr(self._sub_operation, "gate")
             and len(self._controls) == 1
@@ -287,8 +289,8 @@ 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)
 
@@ -301,15 +303,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
+    ) -> Optional[protocols.CircuitDiagramInfo]:
         n = len(self.controls)
 
         sub_args = protocols.CircuitDiagramInfoArgs(