cirq-core 1.6.0.dev20250423233500__py3-none-any.whl → 1.6.0.dev20250425004112__py3-none-any.whl

cirq/ops/linear_combinations.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numbers
 from collections import defaultdict
 from typing import (
@@ -81,7 +83,7 @@ class LinearCombinationOfGates(value.LinearDict[raw_types.Gate]):
         2 * cirq.X - 2 * cirq.Z
     """
 
-    def __init__(self, terms: Mapping[raw_types.Gate, 'cirq.TParamValComplex']) -> None:
+    def __init__(self, terms: Mapping[raw_types.Gate, cirq.TParamValComplex]) -> None:
         """Initializes linear combination from a collection of terms.
 
         Args:
@@ -97,38 +99,38 @@ class LinearCombinationOfGates(value.LinearDict[raw_types.Gate]):
         any_gate = next(iter(self))
         return any_gate.num_qubits()
 
-    def _is_compatible(self, gate: 'cirq.Gate') -> bool:
+    def _is_compatible(self, gate: cirq.Gate) -> bool:
         return self.num_qubits() is None or self.num_qubits() == gate.num_qubits()
 
     def __add__(
-        self, other: Union[raw_types.Gate, 'LinearCombinationOfGates']
-    ) -> 'LinearCombinationOfGates':
+        self, other: Union[raw_types.Gate, LinearCombinationOfGates]
+    ) -> LinearCombinationOfGates:
         if not isinstance(other, LinearCombinationOfGates):
             other = other.wrap_in_linear_combination()
         return super().__add__(other)
 
     def __iadd__(
-        self, other: Union[raw_types.Gate, 'LinearCombinationOfGates']
-    ) -> 'LinearCombinationOfGates':
+        self, other: Union[raw_types.Gate, LinearCombinationOfGates]
+    ) -> LinearCombinationOfGates:
         if not isinstance(other, LinearCombinationOfGates):
             other = other.wrap_in_linear_combination()
         return super().__iadd__(other)
 
     def __sub__(
-        self, other: Union[raw_types.Gate, 'LinearCombinationOfGates']
-    ) -> 'LinearCombinationOfGates':
+        self, other: Union[raw_types.Gate, LinearCombinationOfGates]
+    ) -> LinearCombinationOfGates:
         if not isinstance(other, LinearCombinationOfGates):
             other = other.wrap_in_linear_combination()
         return super().__sub__(other)
 
     def __isub__(
-        self, other: Union[raw_types.Gate, 'LinearCombinationOfGates']
-    ) -> 'LinearCombinationOfGates':
+        self, other: Union[raw_types.Gate, LinearCombinationOfGates]
+    ) -> LinearCombinationOfGates:
         if not isinstance(other, LinearCombinationOfGates):
             other = other.wrap_in_linear_combination()
         return super().__isub__(other)
 
-    def __pow__(self, exponent: int) -> 'LinearCombinationOfGates':
+    def __pow__(self, exponent: int) -> LinearCombinationOfGates:
         if not isinstance(exponent, int):
             return NotImplemented
         if exponent < 0:
@@ -155,8 +157,8 @@ class LinearCombinationOfGates(value.LinearDict[raw_types.Gate]):
         return {name for item in self.items() for name in protocols.parameter_names(item)}
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'LinearCombinationOfGates':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> LinearCombinationOfGates:
         return self.__class__(
             {
                 protocols.resolve_parameters(
@@ -224,7 +226,7 @@ class LinearCombinationOfOperations(value.LinearDict[raw_types.Operation]):
     by the identity operator. Note that A may not be unitary or even normal.
     """
 
-    def __init__(self, terms: Mapping[raw_types.Operation, 'cirq.TParamValComplex']) -> None:
+    def __init__(self, terms: Mapping[raw_types.Operation, cirq.TParamValComplex]) -> None:
         """Initializes linear combination from a collection of terms.
 
         Args:
@@ -233,7 +235,7 @@ class LinearCombinationOfOperations(value.LinearDict[raw_types.Operation]):
         """
         super().__init__(terms, validator=self._is_compatible)
 
-    def _is_compatible(self, operation: 'cirq.Operation') -> bool:
+    def _is_compatible(self, operation: cirq.Operation) -> bool:
         return isinstance(operation, raw_types.Operation)
 
     @property
@@ -245,7 +247,7 @@ class LinearCombinationOfOperations(value.LinearDict[raw_types.Operation]):
         all_qubits = set.union(*qubit_sets)
         return tuple(sorted(all_qubits))
 
-    def __pow__(self, exponent: int) -> 'LinearCombinationOfOperations':
+    def __pow__(self, exponent: int) -> LinearCombinationOfOperations:
         if not isinstance(exponent, int):
             return NotImplemented
         if exponent < 0:
@@ -272,8 +274,8 @@ class LinearCombinationOfOperations(value.LinearDict[raw_types.Operation]):
         return {name for item in self.items() for name in protocols.parameter_names(item)}
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'LinearCombinationOfOperations':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> LinearCombinationOfOperations:
         return self.__class__(
             {
                 protocols.resolve_parameters(op, resolver, recursive): protocols.resolve_parameters(
@@ -317,7 +319,7 @@ class LinearCombinationOfOperations(value.LinearDict[raw_types.Operation]):
         """Computes Pauli expansion of self from Pauli expansions of terms."""
 
         def extend_term(
-            pauli_names: str, qubits: Tuple['cirq.Qid', ...], all_qubits: Tuple['cirq.Qid', ...]
+            pauli_names: str, qubits: Tuple[cirq.Qid, ...], all_qubits: Tuple[cirq.Qid, ...]
         ) -> str:
             """Extends Pauli product on qubits to product on all_qubits."""
             assert len(pauli_names) == len(qubits)
@@ -326,8 +328,8 @@ class LinearCombinationOfOperations(value.LinearDict[raw_types.Operation]):
 
         def extend(
             expansion: value.LinearDict[str],
-            qubits: Tuple['cirq.Qid', ...],
-            all_qubits: Tuple['cirq.Qid', ...],
+            qubits: Tuple[cirq.Qid, ...],
+            all_qubits: Tuple[cirq.Qid, ...],
         ) -> value.LinearDict[str]:
             """Extends Pauli expansion on qubits to expansion on all_qubits."""
             return value.LinearDict(
@@ -358,7 +360,7 @@ def _is_linear_dict_of_unit_pauli_string(linear_dict: value.LinearDict[UnitPauli
 
 
 def _pauli_string_from_unit(
-    unit: UnitPauliStringT, coefficient: Union[int, float, 'cirq.TParamValComplex'] = 1
+    unit: UnitPauliStringT, coefficient: Union[int, float, cirq.TParamValComplex] = 1
 ):
     return PauliString(qubit_pauli_map=dict(unit), coefficient=coefficient)
 
@@ -444,7 +446,7 @@ class PauliSum:
         return self._linear_dict
 
     @staticmethod
-    def wrap(val: PauliSumLike) -> 'PauliSum':
+    def wrap(val: PauliSumLike) -> PauliSum:
         """Convert a `cirq.PauliSumLike` object to a PauliSum
 
         Attempts to convert an existing int, float, complex, `cirq.PauliString`,
@@ -468,7 +470,7 @@ class PauliSum:
         return PauliSum() + val
 
     @classmethod
-    def from_pauli_strings(cls, terms: Union[PauliString, List[PauliString]]) -> 'PauliSum':
+    def from_pauli_strings(cls, terms: Union[PauliString, List[PauliString]]) -> PauliSum:
         """Returns a PauliSum by combining `cirq.PauliString` terms.
 
         Args:
@@ -488,8 +490,8 @@ class PauliSum:
 
     @classmethod
     def from_boolean_expression(
-        cls, boolean_expr: Expr, qubit_map: Dict[str, 'cirq.Qid']
-    ) -> 'PauliSum':
+        cls, boolean_expr: Expr, qubit_map: Dict[str, cirq.Qid]
+    ) -> PauliSum:
         """Builds the Hamiltonian representation of a Boolean expression.
 
         This is based on "On the representation of Boolean and real functions as Hamiltonians for
@@ -545,7 +547,7 @@ class PauliSum:
         qs = {q for k in self._linear_dict.keys() for q, _ in k}
         return tuple(sorted(qs))
 
-    def with_qubits(self, *new_qubits: 'cirq.Qid') -> 'PauliSum':
+    def with_qubits(self, *new_qubits: cirq.Qid) -> PauliSum:
         """Return a new PauliSum on `new_qubits`.
 
         Args:
@@ -569,7 +571,7 @@ class PauliSum:
             new_pauli_strings.append(pauli_string.map_qubits(qubit_map))
         return PauliSum.from_pauli_strings(new_pauli_strings)
 
-    def copy(self) -> 'PauliSum':
+    def copy(self) -> PauliSum:
         """Return a copy of this PauliSum.
 
         Returns: A copy of this PauliSum.
@@ -922,7 +924,7 @@ class ProjectorSum:
     @classmethod
     def from_projector_strings(
         cls, terms: Union[ProjectorString, List[ProjectorString]]
-    ) -> 'ProjectorSum':
+    ) -> ProjectorSum:
         """Builds a ProjectorSum from one or more ProjectorString(s).
 
         Args:
@@ -941,7 +943,7 @@ class ProjectorSum:
             termdict[key] += pstring.coefficient
         return cls(linear_dict=value.LinearDict(termdict))
 
-    def copy(self) -> 'ProjectorSum':
+    def copy(self) -> ProjectorSum:
         return ProjectorSum(self._linear_dict.copy())
 
     def matrix(self, projector_qids: Optional[Iterable[raw_types.Qid]] = None) -> csr_matrix:
@@ -1022,7 +1024,7 @@ class ProjectorSum:
     def __bool__(self) -> bool:
         return bool(self._linear_dict)
 
-    def __iadd__(self, other: Union['ProjectorString', 'ProjectorSum']):
+    def __iadd__(self, other: Union[ProjectorString, ProjectorSum]):
         if isinstance(other, ProjectorString):
             other = ProjectorSum.from_projector_strings(other)
         elif not isinstance(other, ProjectorSum):
@@ -1030,7 +1032,7 @@ class ProjectorSum:
         self._linear_dict += other._linear_dict
         return self
 
-    def __add__(self, other: Union['ProjectorString', 'ProjectorSum']):
+    def __add__(self, other: Union[ProjectorString, ProjectorSum]):
         if isinstance(other, ProjectorString):
             other = ProjectorSum.from_projector_strings(other)
         elif not isinstance(other, ProjectorSum):
@@ -1039,7 +1041,7 @@ class ProjectorSum:
         result += other
         return result
 
-    def __isub__(self, other: Union['ProjectorString', 'ProjectorSum']):
+    def __isub__(self, other: Union[ProjectorString, ProjectorSum]):
         if isinstance(other, ProjectorString):
             other = ProjectorSum.from_projector_strings(other)
         elif not isinstance(other, ProjectorSum):
@@ -1047,7 +1049,7 @@ class ProjectorSum:
         self._linear_dict -= other._linear_dict
         return self
 
-    def __sub__(self, other: Union['ProjectorString', 'ProjectorSum']):
+    def __sub__(self, other: Union[ProjectorString, ProjectorSum]):
         if isinstance(other, ProjectorString):
             other = ProjectorSum.from_projector_strings(other)
         elif not isinstance(other, ProjectorSum):

cirq/ops/matrix_gates.py

@@ -14,6 +14,8 @@
 
 """Quantum gates defined by a matrix."""
 
+from __future__ import annotations
+
 from typing import Any, Dict, Iterable, List, Optional, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -109,7 +111,7 @@ class MatrixGate(raw_types.Gate):
         ):
             raise ValueError(f'Not a unitary matrix: {matrix}')
 
-    def with_name(self, name: str) -> 'MatrixGate':
+    def with_name(self, name: str) -> MatrixGate:
         """Creates a new MatrixGate with the same matrix and a new name."""
         return MatrixGate(self._matrix, name=name, qid_shape=self._qid_shape, unitary_check=False)
 
@@ -127,13 +129,13 @@ class MatrixGate(raw_types.Gate):
     def _qid_shape_(self) -> Tuple[int, ...]:
         return self._qid_shape
 
-    def __pow__(self, exponent: Any) -> 'MatrixGate':
+    def __pow__(self, exponent: Any) -> MatrixGate:
         if not isinstance(exponent, (int, float)):
             return NotImplemented
         new_mat = linalg.map_eigenvalues(self._matrix, lambda b: b**exponent)
         return MatrixGate(new_mat, qid_shape=self._qid_shape)
 
-    def _phase_by_(self, phase_turns: float, qubit_index: int) -> 'MatrixGate':
+    def _phase_by_(self, phase_turns: float, qubit_index: int) -> MatrixGate:
         if not isinstance(phase_turns, (int, float)):
             return NotImplemented
         if self._qid_shape[qubit_index] != 2:
@@ -147,10 +149,10 @@ class MatrixGate(raw_types.Gate):
         result[linalg.slice_for_qubits_equal_to([j], 1)] *= np.conj(p)
         return MatrixGate(matrix=result.reshape(self._matrix.shape), qid_shape=self._qid_shape)
 
-    def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Tuple[cirq.Qid, ...]) -> cirq.OP_TREE:
         from cirq.circuits import Circuit
 
-        decomposed: List['cirq.Operation'] = NotImplemented
+        decomposed: List[cirq.Operation] = NotImplemented
         if self._qid_shape == (2,):
             decomposed = [
                 g.on(qubits[0])
@@ -183,9 +185,7 @@ class MatrixGate(raw_types.Gate):
     def _unitary_(self) -> np.ndarray:
         return np.copy(self._matrix)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         n_qubits = len(self._qid_shape)
         # No diagram for zero-qubit gates; let fallback handle it
         if n_qubits == 0:
@@ -199,7 +199,7 @@ class MatrixGate(raw_types.Gate):
         rest = [f'#{i+1}' for i in range(1, n_qubits)]
         return protocols.CircuitDiagramInfo(wire_symbols=[main, *rest])
 
-    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._qid_shape == (2,):
             return protocols.qasm(
@@ -233,7 +233,7 @@ class MatrixGate(raw_types.Gate):
         return str(self._matrix.round(3))
 
 
-def _matrix_to_diagram_symbol(matrix: np.ndarray, args: 'protocols.CircuitDiagramInfoArgs') -> str:
+def _matrix_to_diagram_symbol(matrix: np.ndarray, args: protocols.CircuitDiagramInfoArgs) -> str:
     if args.precision is not None:
         matrix = matrix.round(args.precision)
     result = str(matrix)

cirq/ops/measure_util.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Callable, Dict, Iterable, List, Optional, overload, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
@@ -31,7 +33,7 @@ def _default_measurement_key(qubits: Iterable[raw_types.Qid]) -> str:
 
 def measure_single_paulistring(
     pauli_observable: pauli_string.PauliString,
-    key: Optional[Union[str, 'cirq.MeasurementKey']] = None,
+    key: Optional[Union[str, cirq.MeasurementKey]] = None,
 ) -> raw_types.Operation:
     """Returns a single PauliMeasurementGate which measures the pauli observable
 
@@ -95,7 +97,7 @@ def measure_paulistring_terms(
 @overload
 def measure(
     *target: raw_types.Qid,
-    key: Optional[Union[str, 'cirq.MeasurementKey']] = None,
+    key: Optional[Union[str, cirq.MeasurementKey]] = None,
     invert_mask: Tuple[bool, ...] = (),
 ) -> raw_types.Operation:
     pass
@@ -105,7 +107,7 @@ def measure(
 def measure(
     __target: Iterable[raw_types.Qid],
     *,
-    key: Optional[Union[str, 'cirq.MeasurementKey']] = None,
+    key: Optional[Union[str, cirq.MeasurementKey]] = None,
     invert_mask: Tuple[bool, ...] = (),
 ) -> raw_types.Operation:
     pass
@@ -113,7 +115,7 @@ def measure(
 
 def measure(
     *target,
-    key: Optional[Union[str, 'cirq.MeasurementKey']] = None,
+    key: Optional[Union[str, cirq.MeasurementKey]] = None,
     invert_mask: Tuple[bool, ...] = (),
     confusion_map: Optional[Dict[Tuple[int, ...], np.ndarray]] = None,
 ) -> raw_types.Operation:

cirq/ops/measurement_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 typing import (
     Any,
     Dict,
@@ -48,7 +50,7 @@ class MeasurementGate(raw_types.Gate):
     def __init__(
         self,
         num_qubits: Optional[int] = None,
-        key: Union[str, 'cirq.MeasurementKey'] = '',
+        key: Union[str, cirq.MeasurementKey] = '',
         invert_mask: Tuple[bool, ...] = (),
         qid_shape: Optional[Tuple[int, ...]] = None,
         confusion_map: Optional[Dict[Tuple[int, ...], np.ndarray]] = None,
@@ -100,7 +102,7 @@ class MeasurementGate(raw_types.Gate):
         return str(self.mkey)
 
     @property
-    def mkey(self) -> 'cirq.MeasurementKey':
+    def mkey(self) -> cirq.MeasurementKey:
         return self._mkey
 
     @property
@@ -117,7 +119,7 @@ class MeasurementGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return False
 
-    def with_key(self, key: Union[str, 'cirq.MeasurementKey']) -> 'MeasurementGate':
+    def with_key(self, key: Union[str, cirq.MeasurementKey]) -> MeasurementGate:
         """Creates a measurement gate with a new key but otherwise identical."""
         if key == self.key:
             return self
@@ -136,14 +138,14 @@ class MeasurementGate(raw_types.Gate):
         return self.with_key(self.mkey._with_key_path_prefix_(prefix))
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
+        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
     ):
         return self.with_key(protocols.with_rescoped_keys(self.mkey, path, bindable_keys))
 
     def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]):
         return self.with_key(protocols.with_measurement_key_mapping(self.mkey, key_map))
 
-    def with_bits_flipped(self, *bit_positions: int) -> 'MeasurementGate':
+    def with_bits_flipped(self, *bit_positions: int) -> MeasurementGate:
         """Toggles whether or not the measurement inverts various outputs.
 
         This only affects the invert_mask, which is applied after confusion
@@ -182,7 +184,7 @@ class MeasurementGate(raw_types.Gate):
     def _measurement_key_name_(self) -> str:
         return self.key
 
-    def _measurement_key_obj_(self) -> 'cirq.MeasurementKey':
+    def _measurement_key_obj_(self) -> cirq.MeasurementKey:
         return self.mkey
 
     def _kraus_(self):
@@ -198,9 +200,7 @@ class MeasurementGate(raw_types.Gate):
     def _has_kraus_(self):
         return True
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         symbols = ['M'] * self.num_qubits()
         flipped_indices = {i for i, x in enumerate(self.full_invert_mask()) if x}
         confused_indices = {x for idxs in self.confusion_map for x in idxs}
@@ -224,7 +224,7 @@ class MeasurementGate(raw_types.Gate):
 
         return protocols.CircuitDiagramInfo(symbols)
 
-    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.confusion_map or not all(d == 2 for d in self._qid_shape):
             return NotImplemented
         args.validate_version('2.0', '3.0')
@@ -243,7 +243,7 @@ class MeasurementGate(raw_types.Gate):
                 lines.append(args.format('x {0};  // Undo the inversion\n', qubit))
         return ''.join(lines)
 
-    def _op_repr_(self, qubits: Sequence['cirq.Qid']) -> str:
+    def _op_repr_(self, qubits: Sequence[cirq.Qid]) -> str:
         args = list(repr(q) for q in qubits)
         if self.key != _default_measurement_key(qubits):
             args.append(f'key={self.mkey!r}')
@@ -304,7 +304,7 @@ class MeasurementGate(raw_types.Gate):
     def _has_stabilizer_effect_(self) -> Optional[bool]:
         return True
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase', qubits: Sequence['cirq.Qid']) -> bool:
+    def _act_on_(self, sim_state: cirq.SimulationStateBase, qubits: Sequence[cirq.Qid]) -> bool:
         from cirq.sim import SimulationState
 
         if not isinstance(sim_state, SimulationState):

cirq/ops/mixed_unitary_channel.py

@@ -1,4 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 from typing import Any, Dict, FrozenSet, Iterable, Mapping, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
@@ -28,7 +31,7 @@ class MixedUnitaryChannel(raw_types.Gate):
     def __init__(
         self,
         mixture: Iterable[Tuple[float, np.ndarray]],
-        key: Union[str, 'cirq.MeasurementKey', None] = None,
+        key: Union[str, cirq.MeasurementKey, None] = None,
         validate: bool = False,
     ):
         mixture = list(mixture)
@@ -58,7 +61,7 @@ class MixedUnitaryChannel(raw_types.Gate):
 
     @staticmethod
     def from_mixture(
-        mixture: 'protocols.SupportsMixture', key: Union[str, 'cirq.MeasurementKey', None] = None
+        mixture: protocols.SupportsMixture, key: Union[str, cirq.MeasurementKey, None] = None
     ):
         """Creates a copy of a mixture with the given measurement key."""
         return MixedUnitaryChannel(mixture=list(protocols.mixture(mixture)), key=key)
@@ -85,7 +88,7 @@ class MixedUnitaryChannel(raw_types.Gate):
             return NotImplemented
         return str(self._key)
 
-    def _measurement_key_obj_(self) -> 'cirq.MeasurementKey':
+    def _measurement_key_obj_(self) -> cirq.MeasurementKey:
         if self._key is None:
             return NotImplemented
         return self._key
@@ -108,7 +111,7 @@ class MixedUnitaryChannel(raw_types.Gate):
         )
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
+        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
     ):
         return MixedUnitaryChannel(
             mixture=self._mixture, key=protocols.with_rescoped_keys(self._key, path, bindable_keys)

cirq/ops/named_qubit.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 functools
 import weakref
 from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING
@@ -93,7 +96,7 @@ class _BaseNamedQid(raw_types.Qid):
     def dimension(self) -> int:
         return self._dimension
 
-    def with_dimension(self, dimension: int) -> 'NamedQid':
+    def with_dimension(self, dimension: int) -> NamedQid:
         return NamedQid(self._name, dimension=dimension)
 
 
@@ -111,7 +114,7 @@ class NamedQid(_BaseNamedQid):
     # Holds weak references so instances can still be garbage collected.
     _cache = weakref.WeakValueDictionary[Tuple[str, int], 'cirq.NamedQid']()
 
-    def __new__(cls, name: str, dimension: int) -> 'cirq.NamedQid':
+    def __new__(cls, name: str, dimension: int) -> cirq.NamedQid:
         """Initializes a `NamedQid` with a given name and dimension.
 
         Args:
@@ -144,7 +147,7 @@ class NamedQid(_BaseNamedQid):
         return f'{self._name} (d={self._dimension})'
 
     @staticmethod
-    def range(*args, prefix: str, dimension: int) -> List['NamedQid']:
+    def range(*args, prefix: str, dimension: int) -> List[NamedQid]:
         """Returns a range of ``NamedQid``\\s.
 
         The range returned starts with the prefix, and followed by a qid for
@@ -186,7 +189,7 @@ class NamedQubit(_BaseNamedQid):
     # Holds weak references so instances can still be garbage collected.
     _cache = weakref.WeakValueDictionary[str, 'cirq.NamedQubit']()
 
-    def __new__(cls, name: str) -> 'cirq.NamedQubit':
+    def __new__(cls, name: str) -> cirq.NamedQubit:
         """Initializes a `NamedQid` with a given name and dimension.
 
         Args:
@@ -216,7 +219,7 @@ class NamedQubit(_BaseNamedQid):
         return f'cirq.NamedQubit({self._name!r})'
 
     @staticmethod
-    def range(*args, prefix: str) -> List['NamedQubit']:
+    def range(*args, prefix: str) -> List[NamedQubit]:
         r"""Returns a range of `cirq.NamedQubit`s.
 
         The range returned starts with the prefix, and followed by a qubit for

cirq/ops/op_tree.py

@@ -14,6 +14,8 @@
 
 """A recursive type describing trees of operations, and utility methods for it."""
 
+from __future__ import annotations
+
 from typing import Callable, Iterable, Iterator, NoReturn, TYPE_CHECKING, Union
 
 from cirq._doc import document
@@ -47,7 +49,7 @@ document(
 
 def flatten_op_tree(
     root: OP_TREE, preserve_moments: bool = False
-) -> Iterator[Union[Operation, 'cirq.Moment']]:
+) -> Iterator[Union[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[Union[Operation, cirq.Moment]]:
     """Performs an in-order iteration OP_TREE, yielding ops and moments.
 
     Args:

cirq/ops/parallel_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, Any, Dict, Optional, Tuple, TYPE_CHECKING, Union
 
@@ -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,9 +93,7 @@ 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)
         )
@@ -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:
@@ -158,7 +156,7 @@ class ParallelGate(raw_types.Gate):
         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: