cirq-core 1.6.0.dev20250424231143__py3-none-any.whl → 1.6.0.dev20250428201230__py3-none-any.whl

cirq/ops/pauli_string_phasor.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 typing import (
     AbstractSet,
@@ -63,10 +65,10 @@ class PauliStringPhasor(gate_operation.GateOperation):
     def __init__(
         self,
         pauli_string: ps.PauliString,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
+        qubits: Optional[Sequence[cirq.Qid]] = None,
         *,
-        exponent_neg: 'cirq.TParamVal' = 1,
-        exponent_pos: 'cirq.TParamVal' = 0,
+        exponent_neg: cirq.TParamVal = 1,
+        exponent_pos: cirq.TParamVal = 0,
     ) -> None:
         """Initializes the operation.
 
@@ -106,34 +108,34 @@ class PauliStringPhasor(gate_operation.GateOperation):
         self._pauli_string = gate.dense_pauli_string.on(*self.qubits)
 
     @property
-    def gate(self) -> 'cirq.PauliStringPhasorGate':
+    def gate(self) -> cirq.PauliStringPhasorGate:
         """The gate applied by the operation."""
         return cast(PauliStringPhasorGate, self._gate)
 
     @property
-    def exponent_neg(self) -> 'cirq.TParamVal':
+    def exponent_neg(self) -> cirq.TParamVal:
         """The negative exponent."""
         return self.gate.exponent_neg
 
     @property
-    def exponent_pos(self) -> 'cirq.TParamVal':
+    def exponent_pos(self) -> cirq.TParamVal:
         """The positive exponent."""
         return self.gate.exponent_pos
 
     @property
-    def pauli_string(self) -> 'cirq.PauliString':
+    def pauli_string(self) -> cirq.PauliString:
         """The underlying pauli string."""
         return self._pauli_string
 
     @property
-    def exponent_relative(self) -> 'cirq.TParamVal':
+    def exponent_relative(self) -> cirq.TParamVal:
         """The relative exponent between negative and positive exponents."""
         return self.gate.exponent_relative
 
     def _value_equality_values_(self):
         return (self.pauli_string, self.qubits, self.exponent_neg, self.exponent_pos)
 
-    def equal_up_to_global_phase(self, other: 'PauliStringPhasor') -> bool:
+    def equal_up_to_global_phase(self, other: PauliStringPhasor) -> bool:
         """Checks equality of two PauliStringPhasors, up to global phase."""
         if isinstance(other, PauliStringPhasor):
             return (
@@ -143,7 +145,7 @@ class PauliStringPhasor(gate_operation.GateOperation):
             )
         return False
 
-    def map_qubits(self, qubit_map: Dict[raw_types.Qid, raw_types.Qid]) -> 'PauliStringPhasor':
+    def map_qubits(self, qubit_map: Dict[raw_types.Qid, raw_types.Qid]) -> PauliStringPhasor:
         """Maps the qubits inside the PauliStringPhasor.
 
         Args:
@@ -168,13 +170,13 @@ class PauliStringPhasor(gate_operation.GateOperation):
             exponent_pos=self.exponent_pos,
         )
 
-    def can_merge_with(self, op: 'PauliStringPhasor') -> bool:
+    def can_merge_with(self, op: PauliStringPhasor) -> bool:
         """Checks whether the underlying PauliStrings can be merged."""
         return (
             self.pauli_string.equal_up_to_coefficient(op.pauli_string) and self.qubits == op.qubits
         )
 
-    def merged_with(self, op: 'PauliStringPhasor') -> 'PauliStringPhasor':
+    def merged_with(self, op: PauliStringPhasor) -> PauliStringPhasor:
         """Merges two PauliStringPhasors."""
         if not self.can_merge_with(op):
             raise ValueError(f'Cannot merge operations: {self}, {op}')
@@ -184,9 +186,7 @@ class PauliStringPhasor(gate_operation.GateOperation):
             self.pauli_string, qubits=self.qubits, exponent_pos=pp, exponent_neg=pn
         )
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         qubits = self.qubits if args.known_qubits is None else args.known_qubits
         if not qubits:
             return NotImplemented
@@ -201,7 +201,7 @@ class PauliStringPhasor(gate_operation.GateOperation):
 
     def pass_operations_over(
         self, ops: Iterable[raw_types.Operation], after_to_before: bool = False
-    ) -> 'PauliStringPhasor':
+    ) -> PauliStringPhasor:
         """Determines how the Pauli phasor changes when conjugated by Cliffords.
 
         The output and input pauli phasors are related by a circuit equivalence.
@@ -277,8 +277,8 @@ class PauliStringPhasorGate(raw_types.Gate):
         self,
         dense_pauli_string: dps.DensePauliString,
         *,
-        exponent_neg: 'cirq.TParamVal' = 1,
-        exponent_pos: 'cirq.TParamVal' = 0,
+        exponent_neg: cirq.TParamVal = 1,
+        exponent_pos: cirq.TParamVal = 0,
     ) -> None:
         """Initializes the PauliStringPhasorGate.
 
@@ -308,29 +308,29 @@ class PauliStringPhasorGate(raw_types.Gate):
         self._exponent_pos = value.canonicalize_half_turns(exponent_pos)
 
     @property
-    def exponent_relative(self) -> 'cirq.TParamVal':
+    def exponent_relative(self) -> cirq.TParamVal:
         """The relative exponent between negative and positive exponents."""
         return value.canonicalize_half_turns(self.exponent_neg - self.exponent_pos)
 
     @property
-    def exponent_neg(self) -> 'cirq.TParamVal':
+    def exponent_neg(self) -> cirq.TParamVal:
         """The negative exponent."""
         return self._exponent_neg
 
     @property
-    def exponent_pos(self) -> 'cirq.TParamVal':
+    def exponent_pos(self) -> cirq.TParamVal:
         """The positive exponent."""
         return self._exponent_pos
 
     @property
-    def dense_pauli_string(self) -> 'cirq.DensePauliString':
+    def dense_pauli_string(self) -> cirq.DensePauliString:
         """The underlying DensePauliString."""
         return self._dense_pauli_string
 
     def _value_equality_values_(self):
         return (self.dense_pauli_string, self.exponent_neg, self.exponent_pos)
 
-    def equal_up_to_global_phase(self, other: 'cirq.PauliStringPhasorGate') -> bool:
+    def equal_up_to_global_phase(self, other: cirq.PauliStringPhasorGate) -> bool:
         """Checks equality of two PauliStringPhasors, up to global phase."""
         if isinstance(other, PauliStringPhasorGate):
             rel1 = self.exponent_relative
@@ -338,7 +338,7 @@ class PauliStringPhasorGate(raw_types.Gate):
             return rel1 == rel2 and self.dense_pauli_string == other.dense_pauli_string
         return False
 
-    def __pow__(self, exponent: Union[float, sympy.Symbol]) -> 'PauliStringPhasorGate':
+    def __pow__(self, exponent: Union[float, sympy.Symbol]) -> PauliStringPhasorGate:
         pn = protocols.mul(self.exponent_neg, exponent, None)
         pp = protocols.mul(self.exponent_pos, exponent, None)
         if pn is None or pp is None:
@@ -348,11 +348,11 @@ class PauliStringPhasorGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return not self._is_parameterized_()
 
-    def _to_z_basis_ops(self, qubits: Sequence['cirq.Qid']) -> Iterator[raw_types.Operation]:
+    def _to_z_basis_ops(self, qubits: Sequence[cirq.Qid]) -> Iterator[raw_types.Operation]:
         """Returns operations to convert the qubits to the computational basis."""
         return self.dense_pauli_string.on(*qubits).to_z_basis_ops()
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         if len(self.dense_pauli_string) <= 0:
             return
         any_qubit = qubits[0]
@@ -387,8 +387,8 @@ class PauliStringPhasorGate(raw_types.Gate):
         )
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'PauliStringPhasorGate':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> PauliStringPhasorGate:
         exponent_neg = resolver.value_of(self.exponent_neg, recursive)
         exponent_pos = resolver.value_of(self.exponent_pos, recursive)
         if isinstance(exponent_neg, numbers.Complex):
@@ -427,7 +427,7 @@ class PauliStringPhasorGate(raw_types.Gate):
         """The number of qubits for the gate."""
         return len(self.dense_pauli_string)
 
-    def on(self, *qubits: 'cirq.Qid') -> 'cirq.PauliStringPhasor':
+    def on(self, *qubits: cirq.Qid) -> cirq.PauliStringPhasor:
         """Creates a PauliStringPhasor on the qubits."""
         return PauliStringPhasor(
             self.dense_pauli_string.on(*qubits),
@@ -443,7 +443,7 @@ class PauliStringPhasorGate(raw_types.Gate):
 
 
 def xor_nonlocal_decompose(
-    qubits: Iterable[raw_types.Qid], onto_qubit: 'cirq.Qid'
+    qubits: Iterable[raw_types.Qid], onto_qubit: cirq.Qid
 ) -> Iterable[raw_types.Operation]:
     """Decomposition ignores connectivity."""
     for qubit in qubits:

cirq/ops/pauli_string_raw_types.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 from typing import Any, Dict, Sequence, Tuple, TYPE_CHECKING
 
@@ -29,14 +31,14 @@ class PauliStringGateOperation(raw_types.Operation, metaclass=abc.ABCMeta):
         self._pauli_string = pauli_string
 
     @property
-    def pauli_string(self) -> 'cirq.PauliString':
+    def pauli_string(self) -> cirq.PauliString:
         return self._pauli_string
 
     def validate_args(self, qubits: Sequence[raw_types.Qid]) -> None:
         if len(qubits) != len(self.pauli_string):
             raise ValueError('Incorrect number of qubits for gate')
 
-    def with_qubits(self, *new_qubits: 'cirq.Qid') -> Self:
+    def with_qubits(self, *new_qubits: cirq.Qid) -> Self:
         self.validate_args(new_qubits)
         return self.map_qubits(dict(zip(self.pauli_string.qubits, new_qubits)))
 
@@ -53,8 +55,8 @@ class PauliStringGateOperation(raw_types.Operation, metaclass=abc.ABCMeta):
         return tuple(self.pauli_string)
 
     def _pauli_string_diagram_info(
-        self, args: 'protocols.CircuitDiagramInfoArgs', exponent: Any = 1
-    ) -> 'cirq.CircuitDiagramInfo':
+        self, args: protocols.CircuitDiagramInfoArgs, exponent: Any = 1
+    ) -> cirq.CircuitDiagramInfo:
         qubits = self.qubits if args.known_qubits is None else args.known_qubits
         syms = tuple(f'[{self.pauli_string[qubit]}]' for qubit in qubits)
         return protocols.CircuitDiagramInfo(wire_symbols=syms, exponent=exponent)

cirq/ops/pauli_sum_exponential.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 from typing import Any, Iterator, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -22,7 +25,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _all_pauli_strings_commute(pauli_sum: 'cirq.PauliSum') -> bool:
+def _all_pauli_strings_commute(pauli_sum: cirq.PauliSum) -> bool:
     for x in pauli_sum:
         for y in pauli_sum:
             if not protocols.commutes(x, y):
@@ -42,10 +45,7 @@ class PauliSumExponential:
     """
 
     def __init__(
-        self,
-        pauli_sum_like: 'cirq.PauliSumLike',
-        exponent: 'cirq.TParamVal' = 1,
-        atol: float = 1e-8,
+        self, pauli_sum_like: cirq.PauliSumLike, exponent: cirq.TParamVal = 1, atol: float = 1e-8
     ):
         pauli_sum = linear_combinations.PauliSum.wrap(pauli_sum_like)
         if not _all_pauli_strings_commute(pauli_sum):
@@ -68,13 +68,13 @@ class PauliSumExponential:
         self._pauli_sum = pauli_sum
 
     @property
-    def qubits(self) -> Tuple['cirq.Qid', ...]:
+    def qubits(self) -> Tuple[cirq.Qid, ...]:
         return self._pauli_sum.qubits
 
     def _value_equality_values_(self) -> Any:
         return (self._pauli_sum, self._exponent)
 
-    def with_qubits(self, *new_qubits: 'cirq.Qid') -> 'PauliSumExponential':
+    def with_qubits(self, *new_qubits: cirq.Qid) -> PauliSumExponential:
         return PauliSumExponential(self._pauli_sum.with_qubits(*new_qubits), self._exponent)
 
     @_compat.cached_method
@@ -82,14 +82,14 @@ class PauliSumExponential:
         return protocols.is_parameterized(self._exponent)
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'PauliSumExponential':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> PauliSumExponential:
         return PauliSumExponential(
             self._pauli_sum,
             exponent=protocols.resolve_parameters(self._exponent, resolver, recursive),
         )
 
-    def __iter__(self) -> Iterator['cirq.PauliStringPhasor']:
+    def __iter__(self) -> Iterator[cirq.PauliStringPhasor]:
         for pauli_string in self._pauli_sum:
             theta = pauli_string.coefficient * self._multiplier
             theta *= self._exponent / np.pi
@@ -119,7 +119,7 @@ class PauliSumExponential:
     def _unitary_(self) -> np.ndarray:
         return self.matrix()
 
-    def __pow__(self, exponent: int) -> 'PauliSumExponential':
+    def __pow__(self, exponent: int) -> PauliSumExponential:
         return PauliSumExponential(self._pauli_sum, self._exponent * exponent)
 
     def __repr__(self) -> str:

cirq/ops/permutation_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, Iterator, Sequence, Tuple, TYPE_CHECKING
 
 from cirq import protocols, value
@@ -73,7 +75,7 @@ class QubitPermutationGate(raw_types.Gate):
     def _has_unitary_(self):
         return True
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         permutation = [p for p in self.permutation]
 
         for i in range(len(permutation)):
@@ -90,7 +92,7 @@ class QubitPermutationGate(raw_types.Gate):
             for idx in cycle[1:]:
                 yield swap_gates.SWAP(qubits[cycle[0]], qubits[idx])
 
-    def _apply_unitary_(self, args: 'cirq.ApplyUnitaryArgs'):
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs):
         # Compute the permutation index list.
         permuted_axes = list(range(len(args.target_tensor.shape)))
         for i in range(len(args.axes)):
@@ -104,7 +106,7 @@ class QubitPermutationGate(raw_types.Gate):
         args.available_buffer[...] = args.target_tensor.transpose(permuted_axes)
         return args.available_buffer
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
         return tuple(f'[{i}>{self.permutation[i]}]' for i in range(len(self.permutation)))
 
     def __repr__(self) -> str:

cirq/ops/phased_iswap_gate.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 """ISWAPPowGate conjugated by tensor product Rz(phi) and Rz(-phi)."""
 
+from __future__ import annotations
+
 from typing import AbstractSet, Any, cast, Dict, Iterator, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
@@ -112,14 +114,14 @@ class PhasedISwapPowGate(eigen_gate.EigenGate):
         )
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'PhasedISwapPowGate':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> PhasedISwapPowGate:
         return self.__class__(
             phase_exponent=protocols.resolve_parameters(self.phase_exponent, resolver, recursive),
             exponent=protocols.resolve_parameters(self.exponent, resolver, recursive),
         )
 
-    def _with_exponent(self, exponent: value.type_alias.TParamVal) -> 'PhasedISwapPowGate':
+    def _with_exponent(self, exponent: value.type_alias.TParamVal) -> PhasedISwapPowGate:
         return PhasedISwapPowGate(
             phase_exponent=self.phase_exponent, exponent=exponent, global_shift=self.global_shift
         )
@@ -137,7 +139,7 @@ class PhasedISwapPowGate(eigen_gate.EigenGate):
             eigen_components.append((eigenvalue, new_projector))
         return eigen_components
 
-    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 NotImplemented
 
@@ -156,7 +158,7 @@ class PhasedISwapPowGate(eigen_gate.EigenGate):
         )
         return args.available_buffer
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         if len(qubits) != 2:
             raise ValueError(f'Expected two qubits, got {len(qubits)}')
         a, b = qubits
@@ -189,9 +191,7 @@ class PhasedISwapPowGate(eigen_gate.EigenGate):
             }
         )
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         s = f'PhISwap({args.format_real(self._phase_exponent)})'
         return protocols.CircuitDiagramInfo(
             wire_symbols=(s, s), exponent=self._diagram_exponent(args)

cirq/ops/phased_x_gate.py

@@ -11,8 +11,11 @@
 # 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.
+
 """An `XPowGate` conjugated by `ZPowGate`s."""
 
+from __future__ import annotations
+
 import math
 import numbers
 from types import NotImplementedType
@@ -64,7 +67,7 @@ class PhasedXPowGate(raw_types.Gate):
         self._exponent = exponent
         self._global_shift = global_shift
 
-    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 cirq.is_parameterized(self):
             return None
 
@@ -92,7 +95,7 @@ class PhasedXPowGate(raw_types.Gate):
             qubits[0],
         )
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         assert len(qubits) == 1
         q = qubits[0]
         z = cirq.Z(q) ** self._phase_exponent
@@ -113,7 +116,7 @@ class PhasedXPowGate(raw_types.Gate):
     def global_shift(self) -> float:
         return self._global_shift
 
-    def __pow__(self, exponent: Union[float, sympy.Expr]) -> 'PhasedXPowGate':
+    def __pow__(self, exponent: Union[float, sympy.Expr]) -> PhasedXPowGate:
         new_exponent = protocols.mul(self._exponent, exponent, NotImplemented)
         if new_exponent is NotImplemented:
             return NotImplemented  # pragma: no cover
@@ -169,9 +172,7 @@ class PhasedXPowGate(raw_types.Gate):
             self._phase_exponent
         )
 
-    def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'PhasedXPowGate':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> PhasedXPowGate:
         """See `cirq.SupportsParameterization`."""
         phase_exponent = resolver.value_of(self._phase_exponent, recursive)
         exponent = resolver.value_of(self._exponent, recursive)
@@ -198,9 +199,7 @@ class PhasedXPowGate(raw_types.Gate):
             global_shift=self._global_shift,
         )
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         """See `cirq.SupportsCircuitDiagramInfo`."""
 
         return protocols.CircuitDiagramInfo(

cirq/ops/phased_x_z_gate.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 typing import AbstractSet, Any, Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
@@ -69,7 +71,7 @@ class PhasedXZGate(raw_types.Gate):
         self._axis_phase_exponent = axis_phase_exponent
 
     @classmethod
-    def from_zyz_angles(cls, z0_rad: float, y_rad: float, z1_rad: float) -> 'cirq.PhasedXZGate':
+    def from_zyz_angles(cls, z0_rad: float, y_rad: float, z1_rad: float) -> cirq.PhasedXZGate:
         r"""Create a PhasedXZGate from ZYZ angles.
 
         The returned gate is equivalent to $Rz(z0\_rad) Ry(y\_rad) Rz(z1\_rad)$ (in time order).
@@ -77,14 +79,14 @@ class PhasedXZGate(raw_types.Gate):
         return cls.from_zyz_exponents(z0=z0_rad / np.pi, y=y_rad / np.pi, z1=z1_rad / np.pi)
 
     @classmethod
-    def from_zyz_exponents(cls, z0: float, y: float, z1: float) -> 'cirq.PhasedXZGate':
+    def from_zyz_exponents(cls, z0: float, y: float, z1: float) -> cirq.PhasedXZGate:
         """Create a PhasedXZGate from ZYZ exponents.
 
         The returned gate is equivalent to $Z^{z0} Y^y Z^{z1}$ (in time order).
         """
         return PhasedXZGate(axis_phase_exponent=-z0 + 0.5, x_exponent=y, z_exponent=z0 + z1)
 
-    def _canonical(self) -> 'cirq.PhasedXZGate':
+    def _canonical(self) -> cirq.PhasedXZGate:
         x = self.x_exponent
         z = self.z_exponent
         a = self.axis_phase_exponent
@@ -146,7 +148,7 @@ class PhasedXZGate(raw_types.Gate):
         )
 
     @staticmethod
-    def from_matrix(mat: np.ndarray) -> 'cirq.PhasedXZGate':
+    def from_matrix(mat: np.ndarray) -> cirq.PhasedXZGate:
         pre_phase, rotation, post_phase = linalg.deconstruct_single_qubit_matrix_into_angles(mat)
         pre_phase /= np.pi
         post_phase /= np.pi
@@ -157,14 +159,14 @@ class PhasedXZGate(raw_types.Gate):
             x_exponent=rotation, axis_phase_exponent=-pre_phase, z_exponent=post_phase + pre_phase
         )._canonical()
 
-    def with_z_exponent(self, z_exponent: Union[float, sympy.Expr]) -> 'cirq.PhasedXZGate':
+    def with_z_exponent(self, z_exponent: Union[float, sympy.Expr]) -> cirq.PhasedXZGate:
         return PhasedXZGate(
             axis_phase_exponent=self._axis_phase_exponent,
             x_exponent=self._x_exponent,
             z_exponent=z_exponent,
         )
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: Tuple[cirq.Qid, ...]) -> Optional[str]:
         from cirq.circuits import qasm_output
 
         qasm_gate = qasm_output.QasmUGate(
@@ -189,13 +191,13 @@ class PhasedXZGate(raw_types.Gate):
         z_post = protocols.unitary(ops.Z ** (self._axis_phase_exponent + self._z_exponent))
         return z_post @ x @ z_pre
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         q = qubits[0]
         yield ops.Z(q) ** -self._axis_phase_exponent
         yield ops.X(q) ** self._x_exponent
         yield ops.Z(q) ** (self._axis_phase_exponent + self._z_exponent)
 
-    def __pow__(self, exponent: float) -> 'PhasedXZGate':
+    def __pow__(self, exponent: float) -> PhasedXZGate:
         if exponent == 1:
             return self
         if exponent == -1:
@@ -223,8 +225,8 @@ class PhasedXZGate(raw_types.Gate):
         )
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.PhasedXZGate':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> cirq.PhasedXZGate:
         """See `cirq.SupportsParameterization`."""
         z_exponent = resolver.value_of(self._z_exponent, recursive)
         x_exponent = resolver.value_of(self._x_exponent, recursive)
@@ -250,7 +252,7 @@ class PhasedXZGate(raw_types.Gate):
             z_exponent=z_exponent, x_exponent=x_exponent, axis_phase_exponent=axis_phase_exponent
         )
 
-    def _phase_by_(self, phase_turns, qubit_index) -> 'cirq.PhasedXZGate':
+    def _phase_by_(self, phase_turns, qubit_index) -> cirq.PhasedXZGate:
         """See `cirq.SupportsPhase`."""
         assert qubit_index == 0
         return PhasedXZGate(
@@ -259,7 +261,7 @@ class PhasedXZGate(raw_types.Gate):
             axis_phase_exponent=self._axis_phase_exponent + phase_turns * 2,
         )
 
-    def _pauli_expansion_(self) -> 'cirq.LinearDict[str]':
+    def _pauli_expansion_(self) -> cirq.LinearDict[str]:
         if protocols.is_parameterized(self):
             return NotImplemented
         x_angle = np.pi * self._x_exponent / 2
@@ -278,7 +280,7 @@ class PhasedXZGate(raw_types.Gate):
             }
         )  # yapf: disable
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> str:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> str:
         """See `cirq.SupportsCircuitDiagramInfo`."""
         return (
             f'PhXZ('

cirq/ops/qid_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 overload, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
@@ -19,18 +21,18 @@ if TYPE_CHECKING:
 
 
 @overload
-def q(__x: int) -> 'cirq.LineQubit': ...
+def q(__x: int) -> cirq.LineQubit: ...
 
 
 @overload
-def q(__row: int, __col: int) -> 'cirq.GridQubit': ...
+def q(__row: int, __col: int) -> cirq.GridQubit: ...
 
 
 @overload
-def q(__name: str) -> 'cirq.NamedQubit': ...
+def q(__name: str) -> cirq.NamedQubit: ...
 
 
-def q(*args: Union[int, str]) -> Union['cirq.LineQubit', 'cirq.GridQubit', 'cirq.NamedQubit']:
+def q(*args: Union[int, str]) -> Union[cirq.LineQubit, cirq.GridQubit, cirq.NamedQubit]:
     """Constructs a qubit id of the appropriate type based on args.
 
     This is shorthand for constructing qubit ids of common types:

cirq/ops/qubit_manager.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 import dataclasses
 from typing import Iterable, List, Tuple, TYPE_CHECKING
@@ -24,15 +26,15 @@ if TYPE_CHECKING:
 
 class QubitManager(metaclass=abc.ABCMeta):
     @abc.abstractmethod
-    def qalloc(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+    def qalloc(self, n: int, dim: int = 2) -> List[cirq.Qid]:
         """Allocate `n` clean qubits, i.e. qubits guaranteed to be in state |0>."""
 
     @abc.abstractmethod
-    def qborrow(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+    def qborrow(self, n: int, dim: int = 2) -> List[cirq.Qid]:
         """Allocate `n` dirty qubits, i.e. the returned qubits can be in any state."""
 
     @abc.abstractmethod
-    def qfree(self, qubits: Iterable['cirq.Qid']) -> None:
+    def qfree(self, qubits: Iterable[cirq.Qid]) -> None:
         """Free pre-allocated clean or dirty qubits managed by this qubit manager."""
 
 
@@ -49,7 +51,7 @@ class _BaseAncillaQid(raw_types.Qid):
     def dimension(self) -> int:
         return self.dim
 
-    def with_dimension(self, dimension: int) -> '_BaseAncillaQid':
+    def with_dimension(self, dimension: int) -> _BaseAncillaQid:
         return dataclasses.replace(self, dim=dimension)
 
     def __repr__(self) -> str:
@@ -82,18 +84,18 @@ class SimpleQubitManager(QubitManager):
         self._borrow_id = 0
         self._prefix = prefix
 
-    def qalloc(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+    def qalloc(self, n: int, dim: int = 2) -> List[cirq.Qid]:
         self._clean_id += n
         return [CleanQubit(i, dim, self._prefix) for i in range(self._clean_id - n, self._clean_id)]
 
-    def qborrow(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+    def qborrow(self, n: int, dim: int = 2) -> List[cirq.Qid]:
         self._borrow_id = self._borrow_id + n
         return [
             BorrowableQubit(i, dim, self._prefix)
             for i in range(self._borrow_id - n, self._borrow_id)
         ]
 
-    def qfree(self, qubits: Iterable['cirq.Qid']) -> None:
+    def qfree(self, qubits: Iterable[cirq.Qid]) -> None:
         for q in qubits:
             good = isinstance(q, CleanQubit) and q.id < self._clean_id
             good |= isinstance(q, BorrowableQubit) and q.id < self._borrow_id