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

cirq/ops/phased_x_gate_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 
 import numpy as np
@@ -24,7 +26,7 @@ import cirq
 @pytest.mark.parametrize(
     'phase_exponent', [-0.5, 0, 0.5, 1, sympy.Symbol('p'), sympy.Symbol('p') + 1]
 )
-def test_phased_x_consistent_protocols(phase_exponent):
+def test_phased_x_consistent_protocols(phase_exponent) -> None:
     cirq.testing.assert_implements_consistent_protocols(
         cirq.PhasedXPowGate(phase_exponent=phase_exponent, exponent=1.0)
     )
@@ -33,7 +35,7 @@ def test_phased_x_consistent_protocols(phase_exponent):
     )
 
 
-def test_init():
+def test_init() -> None:
     g = cirq.PhasedXPowGate(phase_exponent=0.75, exponent=0.25, global_shift=0.1)
     assert g.phase_exponent == 0.75
     assert g.exponent == 0.25
@@ -51,13 +53,13 @@ def test_init():
 
 
 @pytest.mark.parametrize('sym', [sympy.Symbol('a'), sympy.Symbol('a') + 1])
-def test_no_symbolic_qasm_but_fails_gracefully(sym):
+def test_no_symbolic_qasm_but_fails_gracefully(sym) -> None:
     q = cirq.NamedQubit('q')
     v = cirq.PhasedXPowGate(phase_exponent=sym).on(q)
     assert cirq.qasm(v, args=cirq.QasmArgs(), default=None) is None
 
 
-def test_extrapolate():
+def test_extrapolate() -> None:
     g = cirq.PhasedXPowGate(phase_exponent=0.25)
     assert g**0.25 == (g**0.5) ** 0.5
 
@@ -71,7 +73,7 @@ def test_extrapolate():
     assert g**0.5 != (g**3) ** 0.5 == g**-0.5
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(
         cirq.PhasedXPowGate(phase_exponent=0),
@@ -122,7 +124,7 @@ def test_eq():
     )
 
 
-def test_approx_eq():
+def test_approx_eq() -> None:
     assert cirq.approx_eq(
         cirq.PhasedXPowGate(phase_exponent=0.1, exponent=0.2, global_shift=0.3),
         cirq.PhasedXPowGate(phase_exponent=0.1, exponent=0.2, global_shift=0.3),
@@ -140,7 +142,7 @@ def test_approx_eq():
     )
 
 
-def test_str_repr():
+def test_str_repr() -> None:
     assert str(cirq.PhasedXPowGate(phase_exponent=0.25)) == 'PhX(0.25)'
     assert str(cirq.PhasedXPowGate(phase_exponent=0.25, exponent=0.5)) == 'PhX(0.25)**0.5'
     assert repr(
@@ -156,7 +158,7 @@ def test_str_repr():
 @pytest.mark.parametrize(
     'resolve_fn, global_shift', [(cirq.resolve_parameters, 0), (cirq.resolve_parameters_once, 0.1)]
 )
-def test_parameterize(resolve_fn, global_shift):
+def test_parameterize(resolve_fn, global_shift) -> None:
     parameterized_gate = cirq.PhasedXPowGate(
         exponent=sympy.Symbol('a'), phase_exponent=sympy.Symbol('b'), global_shift=global_shift
     )
@@ -187,24 +189,24 @@ def test_parameterize(resolve_fn, global_shift):
     assert cirq.is_parameterized(unparameterized_gate ** sympy.Symbol('a'))
     assert cirq.is_parameterized(unparameterized_gate ** (sympy.Symbol('a') + 1))
 
-    resolver = {'a': 0.5j}
+    resolver_dict = {'a': 0.5j}
     with pytest.raises(ValueError, match='complex value'):
         resolve_fn(
             cirq.PhasedXPowGate(
                 exponent=sympy.Symbol('a'), phase_exponent=0.2, global_shift=global_shift
             ),
-            resolver,
+            resolver_dict,
         )
     with pytest.raises(ValueError, match='complex value'):
         resolve_fn(
             cirq.PhasedXPowGate(
                 exponent=0.1, phase_exponent=sympy.Symbol('a'), global_shift=global_shift
             ),
-            resolver,
+            resolver_dict,
         )
 
 
-def test_trace_bound():
+def test_trace_bound() -> None:
     assert (
         cirq.trace_distance_bound(cirq.PhasedXPowGate(phase_exponent=0.25, exponent=0.001)) < 0.01
     )
@@ -216,7 +218,7 @@ def test_trace_bound():
     )
 
 
-def test_diagram():
+def test_diagram() -> None:
     q = cirq.NamedQubit('q')
     c = cirq.Circuit(
         cirq.PhasedXPowGate(phase_exponent=sympy.Symbol('a'), exponent=sympy.Symbol('b')).on(q),
@@ -234,7 +236,7 @@ q: ───PhX(a)^b───PhX(2*a)^(b + 1)───PhX(0.25)───PhX(1)
     )
 
 
-def test_phase_by():
+def test_phase_by() -> None:
     g = cirq.PhasedXPowGate(phase_exponent=0.25)
     g2 = cirq.phase_by(g, 0.25, 0)
     assert g2 == cirq.PhasedXPowGate(phase_exponent=0.75)
@@ -255,7 +257,7 @@ def test_phase_by():
 @pytest.mark.parametrize(
     'exponent,phase_exponent', itertools.product(np.arange(-2.5, 2.75, 0.25), repeat=2)
 )
-def test_exponent_consistency(exponent, phase_exponent):
+def test_exponent_consistency(exponent, phase_exponent) -> None:
     """Verifies that instances of PhasedX gate expose consistent exponents."""
     g = cirq.PhasedXPowGate(exponent=exponent, phase_exponent=phase_exponent)
     assert g.exponent in [exponent, -exponent]
@@ -269,7 +271,7 @@ def test_exponent_consistency(exponent, phase_exponent):
     assert np.all(u == u2)
 
 
-def test_approx_eq_for_close_phase_exponents():
+def test_approx_eq_for_close_phase_exponents() -> None:
     gate1 = cirq.PhasedXPowGate(phase_exponent=0)
     gate2 = cirq.PhasedXPowGate(phase_exponent=1e-12)
     gate3 = cirq.PhasedXPowGate(phase_exponent=2e-12)

cirq/ops/phased_x_z_gate.py

@@ -12,8 +12,10 @@
 # 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
+from typing import AbstractSet, Any, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -50,9 +52,9 @@ class PhasedXZGate(raw_types.Gate):
     def __init__(
         self,
         *,
-        x_exponent: Union[float, sympy.Expr],
-        z_exponent: Union[float, sympy.Expr],
-        axis_phase_exponent: Union[float, sympy.Expr],
+        x_exponent: float | sympy.Expr,
+        z_exponent: float | sympy.Expr,
+        axis_phase_exponent: float | sympy.Expr,
     ) -> None:
         """Inits PhasedXZGate.
 
@@ -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
@@ -126,15 +128,15 @@ class PhasedXZGate(raw_types.Gate):
         return PhasedXZGate(x_exponent=x, z_exponent=z, axis_phase_exponent=a)
 
     @property
-    def x_exponent(self) -> Union[float, sympy.Expr]:
+    def x_exponent(self) -> float | sympy.Expr:
         return self._x_exponent
 
     @property
-    def z_exponent(self) -> Union[float, sympy.Expr]:
+    def z_exponent(self) -> float | sympy.Expr:
         return self._z_exponent
 
     @property
-    def axis_phase_exponent(self) -> Union[float, sympy.Expr]:
+    def axis_phase_exponent(self) -> float | sympy.Expr:
         return self._axis_phase_exponent
 
     def _value_equality_values_(self):
@@ -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: 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, ...]) -> str | None:
         from cirq.circuits import qasm_output
 
         qasm_gate = qasm_output.QasmUGate(
@@ -180,7 +182,7 @@ class PhasedXZGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return not self._is_parameterized_()
 
-    def _unitary_(self) -> Optional[np.ndarray]:
+    def _unitary_(self) -> np.ndarray | None:
         """See `cirq.SupportsUnitary`."""
         if self._is_parameterized_():
             return None
@@ -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('
@@ -298,7 +300,7 @@ class PhasedXZGate(raw_types.Gate):
             f'z_exponent={proper_repr(self._z_exponent)})'
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(
             self, ['axis_phase_exponent', 'x_exponent', 'z_exponent']
         )

cirq/ops/phased_x_z_gate_test.py

@@ -1,5 +1,9 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import random
+from typing import cast
 
 import numpy as np
 import pytest
@@ -8,14 +12,14 @@ import sympy
 import cirq
 
 
-def test_init_properties():
+def test_init_properties() -> None:
     g = cirq.PhasedXZGate(x_exponent=0.125, z_exponent=0.25, axis_phase_exponent=0.375)
     assert g.x_exponent == 0.125
     assert g.z_exponent == 0.25
     assert g.axis_phase_exponent == 0.375
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(
         lambda: cirq.PhasedXZGate(x_exponent=0.25, z_exponent=0.5, axis_phase_exponent=0.75)
@@ -58,7 +62,7 @@ def test_from_zyz_exponents(z0: float, y: float, z1: float) -> None:
     )
 
 
-def test_canonicalization():
+def test_canonicalization() -> None:
     def f(x, z, a):
         return cirq.PhasedXZGate(x_exponent=x, z_exponent=z, axis_phase_exponent=a)
 
@@ -145,7 +149,7 @@ def test_canonicalization():
     assert t.axis_phase_exponent == 0
 
 
-def test_from_matrix():
+def test_from_matrix() -> None:
     # Axis rotations.
     assert cirq.approx_eq(
         cirq.PhasedXZGate.from_matrix(cirq.unitary(cirq.X**0.1)),
@@ -217,7 +221,7 @@ def test_from_matrix():
         np.array([[0, 1], [1j, 0]]),
     ],
 )
-def test_from_matrix_close_unitary(unitary: np.ndarray):
+def test_from_matrix_close_unitary(unitary: np.ndarray) -> None:
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.unitary(cirq.PhasedXZGate.from_matrix(unitary)), unitary, atol=1e-8
     )
@@ -232,14 +236,14 @@ def test_from_matrix_close_unitary(unitary: np.ndarray):
         np.array([[0, 1], [1j, 0]]),
     ],
 )
-def test_from_matrix_close_kraus(unitary: np.ndarray):
+def test_from_matrix_close_kraus(unitary: np.ndarray) -> None:
     gate = cirq.PhasedXZGate.from_matrix(unitary)
     kraus = cirq.kraus(gate)
     assert len(kraus) == 1
     cirq.testing.assert_allclose_up_to_global_phase(kraus[0], unitary, atol=1e-8)
 
 
-def test_protocols():
+def test_protocols() -> None:
     a = random.random()
     b = random.random()
     c = random.random()
@@ -256,7 +260,7 @@ def test_protocols():
     cirq.testing.assert_implements_consistent_protocols(g)
 
 
-def test_inverse():
+def test_inverse() -> None:
     a = random.random()
     b = random.random()
     c = random.random()
@@ -264,12 +268,14 @@ def test_inverse():
     g = cirq.PhasedXZGate(x_exponent=a, z_exponent=b, axis_phase_exponent=c).on(q)
 
     cirq.testing.assert_allclose_up_to_global_phase(
-        cirq.unitary(g**-1), np.transpose(np.conjugate(cirq.unitary(g))), atol=1e-8
+        cirq.unitary(cast(cirq.GateOperation, g) ** -1),
+        np.transpose(np.conjugate(cirq.unitary(g))),
+        atol=1e-8,
     )
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_parameterized(resolve_fn):
+def test_parameterized(resolve_fn) -> None:
     a = random.random()
     b = random.random()
     c = random.random()
@@ -296,7 +302,7 @@ def test_parameterized(resolve_fn):
         resolve_fn(cirq.PhasedXZGate(x_exponent=a, z_exponent=b, axis_phase_exponent=t), resolver)
 
 
-def test_str_diagram():
+def test_str_diagram() -> None:
     g = cirq.PhasedXZGate(x_exponent=0.5, z_exponent=0.25, axis_phase_exponent=0.125)
 
     assert str(g) == "PhXZ(a=0.125,x=0.5,z=0.25)"

cirq/ops/projector.py

@@ -1,13 +1,18 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import itertools
 import math
-from typing import Any, Dict, Iterable, List, Mapping, Optional
+from typing import Any, Iterable, Mapping, TYPE_CHECKING
 
 import numpy as np
 from scipy.sparse import csr_matrix
 
 from cirq import value
-from cirq.ops import raw_types
+
+if TYPE_CHECKING:
+    import cirq
 
 
 def _check_qids_dimension(qids):
@@ -21,7 +26,7 @@ def _check_qids_dimension(qids):
 class ProjectorString:
     """Mapping of `cirq.Qid` to measurement values (with a coefficient) representing a projector."""
 
-    def __init__(self, projector_dict: Dict[raw_types.Qid, int], coefficient: complex = 1):
+    def __init__(self, projector_dict: dict[cirq.Qid, int], coefficient: complex = 1):
         """Constructor for ProjectorString
 
         Args:
@@ -34,14 +39,14 @@ class ProjectorString:
         self._coefficient = complex(coefficient)
 
     @property
-    def projector_dict(self) -> Dict[raw_types.Qid, int]:
+    def projector_dict(self) -> dict[cirq.Qid, int]:
         return self._projector_dict
 
     @property
     def coefficient(self) -> complex:
         return self._coefficient
 
-    def matrix(self, projector_qids: Optional[Iterable[raw_types.Qid]] = None) -> csr_matrix:
+    def matrix(self, projector_qids: Iterable[cirq.Qid] | None = None) -> csr_matrix:
         """Returns the matrix of self in computational basis of qubits.
 
         Args:
@@ -75,15 +80,15 @@ class ProjectorString:
             ([self._coefficient] * len(ones_idx), (ones_idx, ones_idx)), shape=(total_d, total_d)
         )
 
-    def _get_idx_to_keep(self, qid_map: Mapping[raw_types.Qid, int]):
+    def _get_idx_to_keep(self, qid_map: Mapping[cirq.Qid, int]):
         num_qubits = len(qid_map)
-        idx_to_keep: List[Any] = [slice(0, 2)] * num_qubits
+        idx_to_keep: list[Any] = [slice(0, 2)] * num_qubits
         for q in self.projector_dict.keys():
             idx_to_keep[qid_map[q]] = self.projector_dict[q]
         return tuple(idx_to_keep)
 
     def expectation_from_state_vector(
-        self, state_vector: np.ndarray, qid_map: Mapping[raw_types.Qid, int]
+        self, state_vector: np.ndarray, qid_map: Mapping[cirq.Qid, int]
     ) -> complex:
         """Expectation of the projection from a state vector.
 
@@ -105,7 +110,7 @@ class ProjectorString:
         )
 
     def expectation_from_density_matrix(
-        self, state: np.ndarray, qid_map: Mapping[raw_types.Qid, int]
+        self, state: np.ndarray, qid_map: Mapping[cirq.Qid, int]
     ) -> complex:
         """Expectation of the projection from a density matrix.
 
@@ -130,10 +135,10 @@ class ProjectorString:
     def __repr__(self) -> str:
         return (
             f"cirq.ProjectorString(projector_dict={self._projector_dict},"
-            + f"coefficient={self._coefficient})"
+            f"coefficient={self._coefficient})"
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'projector_dict': list(self._projector_dict.items()),
             'coefficient': self._coefficient,

cirq/ops/projector_test.py

@@ -1,11 +1,14 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import numpy as np
 import pytest
 
 import cirq
 
 
-def test_projector_matrix():
+def test_projector_matrix() -> None:
     q0 = cirq.NamedQubit('q0')
 
     zero_projector = cirq.ProjectorString({q0: 0})
@@ -15,11 +18,11 @@ def test_projector_matrix():
     np.testing.assert_allclose(zero_projector.matrix().toarray(), [[1.0, 0.0], [0.0, 0.0]])
     np.testing.assert_allclose(one_projector.matrix().toarray(), [[0.0, 0.0], [0.0, 1.0]])
     np.testing.assert_allclose(
-        coeff_projector.matrix().toarray(), [[1.23 + 4.56j, 0.0], [0.0, 0.0]]
+        coeff_projector.matrix().toarray(), np.asarray([[1.23 + 4.56j, 0.0], [0.0, 0.0]])
     )
 
 
-def test_projector_repr():
+def test_projector_repr() -> None:
     q0 = cirq.NamedQubit('q0')
 
     assert (
@@ -28,14 +31,14 @@ def test_projector_repr():
     )
 
 
-def test_projector_from_np_array():
+def test_projector_from_np_array() -> None:
     q0 = cirq.NamedQubit('q0')
 
     zero_projector = cirq.ProjectorString({q0: 0})
     np.testing.assert_allclose(zero_projector.matrix().toarray(), [[1.0, 0.0], [0.0, 0.0]])
 
 
-def test_projector_matrix_missing_qid():
+def test_projector_matrix_missing_qid() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     proj = cirq.ProjectorString({q0: 0})
     proj_with_coefficient = cirq.ProjectorString({q0: 0}, 1.23 + 4.56j)
@@ -53,7 +56,7 @@ def test_projector_matrix_missing_qid():
     )
 
 
-def test_equality():
+def test_equality() -> None:
     q0 = cirq.NamedQubit('q0')
 
     obj1a = cirq.ProjectorString({q0: 0})
@@ -67,7 +70,7 @@ def test_equality():
     eq.add_equality_group(obj3)
 
 
-def test_get_values():
+def test_get_values() -> None:
     q0 = cirq.NamedQubit('q0')
     d = cirq.ProjectorString({q0: 0}, 1.23 + 4.56j)
 
@@ -76,14 +79,14 @@ def test_get_values():
     assert d.coefficient == 1.23 + 4.56j
 
 
-def test_expectation_from_state_vector_basis_states_empty():
+def test_expectation_from_state_vector_basis_states_empty() -> None:
     q0 = cirq.NamedQubit('q0')
     d = cirq.ProjectorString({})
 
     np.testing.assert_allclose(d.expectation_from_state_vector(np.array([1.0, 0.0]), {q0: 0}), 1.0)
 
 
-def test_expectation_from_state_vector_basis_states_single_qubits():
+def test_expectation_from_state_vector_basis_states_single_qubits() -> None:
     q0 = cirq.NamedQubit('q0')
     d = cirq.ProjectorString({q0: 0})
 
@@ -91,7 +94,7 @@ def test_expectation_from_state_vector_basis_states_single_qubits():
     np.testing.assert_allclose(d.expectation_from_state_vector(np.array([0.0, 1.0]), {q0: 0}), 0.0)
 
 
-def test_expectation_from_state_vector_basis_states_three_qubits():
+def test_expectation_from_state_vector_basis_states_three_qubits() -> None:
     q0 = cirq.NamedQubit('q0')
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
@@ -141,7 +144,7 @@ def test_expectation_from_state_vector_basis_states_three_qubits():
     )
 
 
-def test_expectation_from_density_matrix_three_qubits():
+def test_expectation_from_density_matrix_three_qubits() -> None:
     q0 = cirq.NamedQubit('q0')
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
@@ -191,7 +194,7 @@ def test_expectation_from_density_matrix_three_qubits():
     )
 
 
-def test_consistency_state_vector_and_density_matrix():
+def test_consistency_state_vector_and_density_matrix() -> None:
     q0 = cirq.NamedQubit('q0')
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
@@ -209,7 +212,7 @@ def test_consistency_state_vector_and_density_matrix():
             )
 
 
-def test_expectation_higher_dims():
+def test_expectation_higher_dims() -> None:
     qubit = cirq.NamedQid('q0', dimension=2)
     qutrit = cirq.NamedQid('q1', dimension=3)
 
@@ -221,7 +224,7 @@ def test_expectation_higher_dims():
         _ = (d.expectation_from_state_vector(np.zeros(2 * 3), {qubit: 0, qutrit: 0}),)
 
 
-def test_expectation_with_coefficient():
+def test_expectation_with_coefficient() -> None:
     q0 = cirq.NamedQubit('q0')
     d = cirq.ProjectorString({q0: 0}, coefficient=(0.6 + 0.4j))
 
@@ -234,7 +237,7 @@ def test_expectation_with_coefficient():
     )
 
 
-def test_expectation_from_density_matrix_basis_states_empty():
+def test_expectation_from_density_matrix_basis_states_empty() -> None:
     q0 = cirq.NamedQubit('q0')
     d = cirq.ProjectorString({})
 
@@ -243,7 +246,7 @@ def test_expectation_from_density_matrix_basis_states_empty():
     )
 
 
-def test_expectation_from_density_matrix_basis_states_single_qubits():
+def test_expectation_from_density_matrix_basis_states_single_qubits() -> None:
     q0 = cirq.NamedQubit('q0')
     d = cirq.ProjectorString({q0: 0})
 

cirq/ops/qid_util.py

@@ -12,25 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import overload, TYPE_CHECKING, Union
+from __future__ import annotations
+
+from typing import overload, TYPE_CHECKING
 
 if TYPE_CHECKING:
     import cirq
 
 
 @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: int | str) -> 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/qid_util_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq