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

cirq/ops/parity_gates_test.py

@@ -14,6 +14,8 @@
 
 """Tests for `parity_gates.py`."""
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 import sympy
@@ -22,17 +24,17 @@ import cirq
 
 
 @pytest.mark.parametrize('eigen_gate_type', [cirq.XXPowGate, cirq.YYPowGate, cirq.ZZPowGate])
-def test_eigen_gates_consistent_protocols(eigen_gate_type):
+def test_eigen_gates_consistent_protocols(eigen_gate_type) -> None:
     cirq.testing.assert_eigengate_implements_consistent_protocols(eigen_gate_type)
 
 
-def test_xx_init():
+def test_xx_init() -> None:
     assert cirq.XXPowGate(exponent=1).exponent == 1
     v = cirq.XXPowGate(exponent=0.5)
     assert v.exponent == 0.5
 
 
-def test_xx_eq():
+def test_xx_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(
         cirq.XX,
@@ -49,24 +51,24 @@ def test_xx_eq():
     eq.add_equality_group(iXX**2.5, iXX**6.5)
 
 
-def test_xx_pow():
+def test_xx_pow() -> None:
     assert cirq.XX**0.5 != cirq.XX**-0.5
     assert cirq.XX**-1 == cirq.XX
     assert (cirq.XX**-1) ** 0.5 == cirq.XX**-0.5
 
 
-def test_xx_str():
+def test_xx_str() -> None:
     assert str(cirq.XX) == 'XX'
     assert str(cirq.XX**0.5) == 'XX**0.5'
     assert str(cirq.XXPowGate(global_shift=0.1)) == 'XX'
 
 
-def test_xx_repr():
+def test_xx_repr() -> None:
     assert repr(cirq.XXPowGate()) == 'cirq.XX'
     assert repr(cirq.XXPowGate(exponent=0.5)) == '(cirq.XX**0.5)'
 
 
-def test_xx_matrix():
+def test_xx_matrix() -> None:
     np.testing.assert_allclose(
         cirq.unitary(cirq.XX),
         np.array([[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]]),
@@ -82,7 +84,7 @@ def test_xx_matrix():
     )
 
 
-def test_xx_diagrams():
+def test_xx_diagrams() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     circuit = cirq.Circuit(cirq.XX(a, b), cirq.XX(a, b) ** 3, cirq.XX(a, b) ** 0.5)
@@ -96,13 +98,13 @@ b: ───XX───XX───XX^0.5───
     )
 
 
-def test_yy_init():
+def test_yy_init() -> None:
     assert cirq.YYPowGate(exponent=1).exponent == 1
     v = cirq.YYPowGate(exponent=0.5)
     assert v.exponent == 0.5
 
 
-def test_yy_eq():
+def test_yy_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(
         cirq.YY,
@@ -118,13 +120,13 @@ def test_yy_eq():
     eq.add_equality_group(iYY**2.5, iYY**6.5)
 
 
-def test_yy_pow():
+def test_yy_pow() -> None:
     assert cirq.YY**0.5 != cirq.YY**-0.5
     assert cirq.YY**-1 == cirq.YY
     assert (cirq.YY**-1) ** 0.5 == cirq.YY**-0.5
 
 
-def test_yy_str():
+def test_yy_str() -> None:
     assert str(cirq.YY) == 'YY'
     assert str(cirq.YY**0.5) == 'YY**0.5'
     assert str(cirq.YYPowGate(global_shift=0.1)) == 'YY'
@@ -133,12 +135,12 @@ def test_yy_str():
     assert str(iYY) == 'YY'
 
 
-def test_yy_repr():
+def test_yy_repr() -> None:
     assert repr(cirq.YYPowGate()) == 'cirq.YY'
     assert repr(cirq.YYPowGate(exponent=0.5)) == '(cirq.YY**0.5)'
 
 
-def test_yy_matrix():
+def test_yy_matrix() -> None:
     np.testing.assert_allclose(
         cirq.unitary(cirq.YY),
         np.array([[0, 0, 0, -1], [0, 0, 1, 0], [0, 1, 0, 0], [-1, 0, 0, 0]]),
@@ -154,7 +156,7 @@ def test_yy_matrix():
     )
 
 
-def test_yy_diagrams():
+def test_yy_diagrams() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     circuit = cirq.Circuit(cirq.YY(a, b), cirq.YY(a, b) ** 3, cirq.YY(a, b) ** 0.5)
@@ -168,13 +170,13 @@ b: ───YY───YY───YY^0.5───
     )
 
 
-def test_zz_init():
+def test_zz_init() -> None:
     assert cirq.ZZPowGate(exponent=1).exponent == 1
     v = cirq.ZZPowGate(exponent=0.5)
     assert v.exponent == 0.5
 
 
-def test_zz_eq():
+def test_zz_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(
         cirq.ZZ,
@@ -190,19 +192,19 @@ def test_zz_eq():
     eq.add_equality_group(iZZ**2.5, iZZ**6.5)
 
 
-def test_zz_pow():
+def test_zz_pow() -> None:
     assert cirq.ZZ**0.5 != cirq.ZZ**-0.5
     assert cirq.ZZ**-1 == cirq.ZZ
     assert (cirq.ZZ**-1) ** 0.5 == cirq.ZZ**-0.5
 
 
-def test_zz_phase_by():
+def test_zz_phase_by() -> None:
     assert cirq.phase_by(cirq.ZZ, 0.25, 0) == cirq.phase_by(cirq.ZZ, 0.25, 1) == cirq.ZZ
     assert cirq.phase_by(cirq.ZZ**0.5, 0.25, 0) == cirq.ZZ**0.5
     assert cirq.phase_by(cirq.ZZ**-0.5, 0.25, 1) == cirq.ZZ**-0.5
 
 
-def test_zz_str():
+def test_zz_str() -> None:
     assert str(cirq.ZZ) == 'ZZ'
     assert str(cirq.ZZ**0.5) == 'ZZ**0.5'
     assert str(cirq.ZZPowGate(global_shift=0.1)) == 'ZZ'
@@ -211,12 +213,12 @@ def test_zz_str():
     assert str(iZZ) == 'ZZ'
 
 
-def test_zz_repr():
+def test_zz_repr() -> None:
     assert repr(cirq.ZZPowGate()) == 'cirq.ZZ'
     assert repr(cirq.ZZPowGate(exponent=0.5)) == '(cirq.ZZ**0.5)'
 
 
-def test_zz_matrix():
+def test_zz_matrix() -> None:
     np.testing.assert_allclose(
         cirq.unitary(cirq.ZZ),
         np.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1]]),
@@ -232,7 +234,7 @@ def test_zz_matrix():
     )
 
 
-def test_zz_diagrams():
+def test_zz_diagrams() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     circuit = cirq.Circuit(cirq.ZZ(a, b), cirq.ZZ(a, b) ** 3, cirq.ZZ(a, b) ** 0.5)
@@ -246,7 +248,7 @@ b: ───ZZ───ZZ───ZZ^0.5───
     )
 
 
-def test_trace_distance():
+def test_trace_distance() -> None:
     foo = sympy.Symbol('foo')
     assert cirq.trace_distance_bound(cirq.XX**foo) == 1.0
     assert cirq.trace_distance_bound(cirq.YY**foo) == 1.0
@@ -256,7 +258,7 @@ def test_trace_distance():
     assert cirq.approx_eq(cirq.trace_distance_bound(cirq.ZZ ** (1 / 3)), np.sin(np.pi / 6))
 
 
-def test_ms_arguments():
+def test_ms_arguments() -> None:
     eq_tester = cirq.testing.EqualsTester()
     eq_tester.add_equality_group(
         cirq.ms(np.pi / 2), cirq.MSGate(rads=np.pi / 2), cirq.XXPowGate(global_shift=-0.5)
@@ -268,7 +270,7 @@ def test_ms_arguments():
     eq_tester.add_equality_group(cirq.XX**0.5)
 
 
-def test_ms_equal_up_to_global_phase():
+def test_ms_equal_up_to_global_phase() -> None:
     assert cirq.equal_up_to_global_phase(cirq.ms(np.pi / 2), cirq.XX)
     assert cirq.equal_up_to_global_phase(cirq.ms(np.pi / 4), cirq.XX**0.5)
     assert not cirq.equal_up_to_global_phase(cirq.ms(np.pi / 4), cirq.XX)
@@ -278,7 +280,7 @@ def test_ms_equal_up_to_global_phase():
     assert cirq.ms(np.pi / 4) not in cirq.GateFamily(cirq.XX)
 
 
-def test_ms_str():
+def test_ms_str() -> None:
     ms = cirq.ms(np.pi / 2)
     assert str(ms) == 'MS(π/2)'
     assert str(cirq.ms(np.pi)) == 'MS(2.0π/2)'
@@ -287,7 +289,7 @@ def test_ms_str():
     assert str(ms**-1) == 'MS(-1.0π/2)'
 
 
-def test_ms_matrix():
+def test_ms_matrix() -> None:
     s = np.sqrt(0.5)
     # yapf: disable
     np.testing.assert_allclose(cirq.unitary(cirq.ms(np.pi/4)),
@@ -300,7 +302,7 @@ def test_ms_matrix():
     np.testing.assert_allclose(cirq.unitary(cirq.ms(np.pi)), np.diag([-1, -1, -1, -1]), atol=1e-8)
 
 
-def test_ms_repr():
+def test_ms_repr() -> None:
     assert repr(cirq.ms(np.pi / 2)) == 'cirq.ms(np.pi/2)'
     assert repr(cirq.ms(np.pi / 4)) == 'cirq.ms(0.5*np.pi/2)'
     cirq.testing.assert_equivalent_repr(cirq.ms(np.pi / 4))
@@ -309,7 +311,7 @@ def test_ms_repr():
     assert repr(ms**-0.5) == 'cirq.ms(-0.5*np.pi/2)'
 
 
-def test_ms_diagrams():
+def test_ms_diagrams() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     circuit = cirq.Circuit(cirq.SWAP(a, b), cirq.X(a), cirq.Y(a), cirq.ms(np.pi).on(a, b))
@@ -323,7 +325,7 @@ b: ───×───────────MS(π)───
     )
 
 
-def test_json_serialization():
+def test_json_serialization() -> None:
     assert cirq.read_json(json_text=cirq.to_json(cirq.ms(np.pi / 2))) == cirq.ms(np.pi / 2)
 
 
@@ -332,7 +334,9 @@ def test_json_serialization():
     'exponent,is_clifford',
     ((0, True), (0.5, True), (0.75, False), (1, True), (1.5, True), (-1.5, True)),
 )
-def test_clifford_protocols(gate_cls: type[cirq.EigenGate], exponent: float, is_clifford: bool):
+def test_clifford_protocols(
+    gate_cls: type[cirq.EigenGate], exponent: float, is_clifford: bool
+) -> None:
     gate = gate_cls(exponent=exponent)
     assert hasattr(gate, '_decompose_into_clifford_with_qubits_')
     if is_clifford:

cirq/ops/pauli_gates.py

@@ -11,9 +11,12 @@
 # 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
 from types import NotImplementedType
-from typing import Any, cast, Dict, Tuple, TYPE_CHECKING, Union
+from typing import Any, cast, TYPE_CHECKING
 
 from cirq._doc import document
 from cirq._import import LazyLoader
@@ -39,14 +42,14 @@ class Pauli(raw_types.Gate, metaclass=abc.ABCMeta):
     of private subclasses are the X, Y, or Z Pauli gates defined below.
     """
 
-    _XYZ: Tuple['Pauli', 'Pauli', 'Pauli']
+    _XYZ: tuple[Pauli, Pauli, Pauli]
 
     @staticmethod
-    def by_index(index: int) -> 'Pauli':
+    def by_index(index: int) -> Pauli:
         return Pauli._XYZ[index % 3]
 
     @staticmethod
-    def by_relative_index(p: 'Pauli', relative_index: int) -> 'Pauli':
+    def by_relative_index(p: Pauli, relative_index: int) -> Pauli:
         return Pauli._XYZ[(p._index + relative_index) % 3]
 
     def __init__(self, index: int, name: str) -> None:
@@ -56,23 +59,21 @@ class Pauli(raw_types.Gate, metaclass=abc.ABCMeta):
     def num_qubits(self):
         return 1
 
-    def _commutes_(
-        self, other: Any, *, atol: float = 1e-8
-    ) -> Union[bool, NotImplementedType, None]:
+    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> bool | NotImplementedType | None:
         if not isinstance(other, Pauli):
             return NotImplemented
         return self is other
 
-    def third(self, second: 'Pauli') -> 'Pauli':
+    def third(self, second: Pauli) -> Pauli:
         return Pauli._XYZ[(-self._index - second._index) % 3]
 
-    def relative_index(self, second: 'Pauli') -> int:
+    def relative_index(self, second: Pauli) -> int:
         """Relative index of self w.r.t. second in the (X, Y, Z) cycle."""
         return (self._index - second._index + 1) % 3 - 1
 
     def phased_pauli_product(
-        self, other: Union['cirq.Pauli', 'identity.IdentityGate']
-    ) -> Tuple[complex, Union['cirq.Pauli', 'identity.IdentityGate']]:
+        self, other: cirq.Pauli | identity.IdentityGate
+    ) -> tuple[complex, cirq.Pauli | identity.IdentityGate]:
         if self == other:
             return 1, identity.I
         if other is identity.I:
@@ -89,7 +90,7 @@ class Pauli(raw_types.Gate, metaclass=abc.ABCMeta):
             return NotImplemented
         return (other._index - self._index) % 3 == 1
 
-    def on(self, *qubits: 'cirq.Qid') -> 'SingleQubitPauliStringGateOperation':
+    def on(self, *qubits: cirq.Qid) -> SingleQubitPauliStringGateOperation:
         """Returns an application of this gate to the given qubits.
 
         Args:
@@ -109,10 +110,10 @@ class _PauliX(Pauli, common_gates.XPowGate):
         Pauli.__init__(self, index=0, name='X')
         common_gates.XPowGate.__init__(self, exponent=1.0)
 
-    def __pow__(self, exponent: 'cirq.TParamVal') -> common_gates.XPowGate:
+    def __pow__(self, exponent: cirq.TParamVal) -> common_gates.XPowGate:
         return common_gates.XPowGate(exponent=exponent) if exponent != 1 else _PauliX()
 
-    def _with_exponent(self, exponent: 'cirq.TParamVal') -> common_gates.XPowGate:
+    def _with_exponent(self, exponent: cirq.TParamVal) -> common_gates.XPowGate:
         return self.__pow__(exponent)
 
     @classmethod
@@ -122,7 +123,7 @@ class _PauliX(Pauli, common_gates.XPowGate):
         return Pauli._XYZ[0]
 
     @property
-    def basis(self) -> Dict[int, '_XEigenState']:
+    def basis(self) -> dict[int, _XEigenState]:
         from cirq.value.product_state import _XEigenState
 
         return {+1: _XEigenState(+1), -1: _XEigenState(-1)}
@@ -133,10 +134,10 @@ class _PauliY(Pauli, common_gates.YPowGate):
         Pauli.__init__(self, index=1, name='Y')
         common_gates.YPowGate.__init__(self, exponent=1.0)
 
-    def __pow__(self, exponent: 'cirq.TParamVal') -> common_gates.YPowGate:
+    def __pow__(self, exponent: cirq.TParamVal) -> common_gates.YPowGate:
         return common_gates.YPowGate(exponent=exponent) if exponent != 1 else _PauliY()
 
-    def _with_exponent(self, exponent: 'cirq.TParamVal') -> common_gates.YPowGate:
+    def _with_exponent(self, exponent: cirq.TParamVal) -> common_gates.YPowGate:
         return self.__pow__(exponent)
 
     @classmethod
@@ -146,7 +147,7 @@ class _PauliY(Pauli, common_gates.YPowGate):
         return Pauli._XYZ[1]
 
     @property
-    def basis(self) -> Dict[int, '_YEigenState']:
+    def basis(self) -> dict[int, _YEigenState]:
         from cirq.value.product_state import _YEigenState
 
         return {+1: _YEigenState(+1), -1: _YEigenState(-1)}
@@ -157,10 +158,10 @@ class _PauliZ(Pauli, common_gates.ZPowGate):
         Pauli.__init__(self, index=2, name='Z')
         common_gates.ZPowGate.__init__(self, exponent=1.0)
 
-    def __pow__(self, exponent: 'cirq.TParamVal') -> common_gates.ZPowGate:
+    def __pow__(self, exponent: cirq.TParamVal) -> common_gates.ZPowGate:
         return common_gates.ZPowGate(exponent=exponent) if exponent != 1 else _PauliZ()
 
-    def _with_exponent(self, exponent: 'cirq.TParamVal') -> common_gates.ZPowGate:
+    def _with_exponent(self, exponent: cirq.TParamVal) -> common_gates.ZPowGate:
         return self.__pow__(exponent)
 
     @classmethod
@@ -170,7 +171,7 @@ class _PauliZ(Pauli, common_gates.ZPowGate):
         return Pauli._XYZ[2]
 
     @property
-    def basis(self) -> Dict[int, '_ZEigenState']:
+    def basis(self) -> dict[int, _ZEigenState]:
         from cirq.value.product_state import _ZEigenState
 
         return {+1: _ZEigenState(+1), -1: _ZEigenState(-1)}

cirq/ops/pauli_gates_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
@@ -20,14 +22,14 @@ import pytest
 import cirq
 
 
-def test_equals():
+def test_equals() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.X, cirq.ops.pauli_gates.X, cirq.XPowGate())
     eq.add_equality_group(cirq.Y, cirq.ops.pauli_gates.Y, cirq.YPowGate())
     eq.add_equality_group(cirq.Z, cirq.ops.pauli_gates.Z, cirq.ZPowGate())
 
 
-def test_phased_pauli_product():
+def test_phased_pauli_product() -> None:
     assert cirq.X.phased_pauli_product(cirq.I) == (1, cirq.X)
     assert cirq.X.phased_pauli_product(cirq.X) == (1, cirq.I)
     assert cirq.X.phased_pauli_product(cirq.Y) == (1j, cirq.Z)
@@ -44,7 +46,7 @@ def test_phased_pauli_product():
     assert cirq.Z.phased_pauli_product(cirq.Z) == (1, cirq.I)
 
 
-def test_isinstance():
+def test_isinstance() -> None:
     assert isinstance(cirq.X, cirq.XPowGate)
     assert isinstance(cirq.Y, cirq.YPowGate)
     assert isinstance(cirq.Z, cirq.ZPowGate)
@@ -59,14 +61,14 @@ def test_isinstance():
     assert not isinstance(cirq.Z, cirq.YPowGate)
 
 
-def test_by_index():
+def test_by_index() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.X, *[cirq.Pauli.by_index(i) for i in (-3, 0, 3, 6)])
     eq.add_equality_group(cirq.Y, *[cirq.Pauli.by_index(i) for i in (-2, 1, 4, 7)])
     eq.add_equality_group(cirq.Z, *[cirq.Pauli.by_index(i) for i in (-1, 2, 5, 8)])
 
 
-def test_relative_index():
+def test_relative_index() -> None:
     assert cirq.X.relative_index(cirq.X) == 0
     assert cirq.X.relative_index(cirq.Y) == -1
     assert cirq.X.relative_index(cirq.Z) == 1
@@ -78,7 +80,7 @@ def test_relative_index():
     assert cirq.Z.relative_index(cirq.Z) == 0
 
 
-def test_by_relative_index():
+def test_by_relative_index() -> None:
     assert cirq.Pauli.by_relative_index(cirq.X, -1) == cirq.Z
     assert cirq.Pauli.by_relative_index(cirq.X, 0) == cirq.X
     assert cirq.Pauli.by_relative_index(cirq.X, 1) == cirq.Y
@@ -96,7 +98,7 @@ def test_by_relative_index():
     assert cirq.Pauli.by_relative_index(cirq.Z, 3) == cirq.Z
 
 
-def test_too_many_qubits():
+def test_too_many_qubits() -> None:
     a, b = cirq.LineQubit.range(2)
     with pytest.raises(ValueError, match='single qubit'):
         _ = cirq.X.on(a, b)
@@ -106,14 +108,14 @@ def test_too_many_qubits():
         _ = x.with_qubits(a, b)
 
 
-def test_relative_index_consistency():
+def test_relative_index_consistency() -> None:
     for pauli_1 in (cirq.X, cirq.Y, cirq.Z):
         for pauli_2 in (cirq.X, cirq.Y, cirq.Z):
             shift = pauli_2.relative_index(pauli_1)
             assert cirq.Pauli.by_relative_index(pauli_1, shift) == pauli_2
 
 
-def test_gt():
+def test_gt() -> None:
     assert not cirq.X > cirq.X
     assert not cirq.X > cirq.Y
     assert cirq.X > cirq.Z
@@ -125,12 +127,12 @@ def test_gt():
     assert not cirq.Z > cirq.Z
 
 
-def test_gt_other_type():
+def test_gt_other_type() -> None:
     with pytest.raises(TypeError):
         _ = cirq.X > object()
 
 
-def test_lt():
+def test_lt() -> None:
     assert not cirq.X < cirq.X
     assert cirq.X < cirq.Y
     assert not cirq.X < cirq.Z
@@ -142,24 +144,24 @@ def test_lt():
     assert not cirq.Z < cirq.Z
 
 
-def test_lt_other_type():
+def test_lt_other_type() -> None:
     with pytest.raises(TypeError):
         _ = cirq.X < object()
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.X) == 'X'
     assert str(cirq.Y) == 'Y'
     assert str(cirq.Z) == 'Z'
 
 
-def test_repr():
+def test_repr() -> None:
     assert repr(cirq.X) == 'cirq.X'
     assert repr(cirq.Y) == 'cirq.Y'
     assert repr(cirq.Z) == 'cirq.Z'
 
 
-def test_third():
+def test_third() -> None:
     assert cirq.X.third(cirq.Y) == cirq.Z
     assert cirq.Y.third(cirq.X) == cirq.Z
     assert cirq.Y.third(cirq.Z) == cirq.X
@@ -172,7 +174,7 @@ def test_third():
     assert cirq.Z.third(cirq.Z) == cirq.Z
 
 
-def test_commutes():
+def test_commutes() -> None:
     for A, B in itertools.product([cirq.X, cirq.Y, cirq.Z], repeat=2):
         assert cirq.commutes(A, B) == (A == B)
     with pytest.raises(TypeError):
@@ -181,19 +183,19 @@ def test_commutes():
     assert cirq.commutes(cirq.Z, cirq.read_json(json_text=cirq.to_json(cirq.Z)))
 
 
-def test_unitary():
+def test_unitary() -> None:
     np.testing.assert_equal(cirq.unitary(cirq.X), cirq.unitary(cirq.X))
     np.testing.assert_equal(cirq.unitary(cirq.Y), cirq.unitary(cirq.Y))
     np.testing.assert_equal(cirq.unitary(cirq.Z), cirq.unitary(cirq.Z))
 
 
-def test_apply_unitary():
+def test_apply_unitary() -> None:
     cirq.testing.assert_has_consistent_apply_unitary(cirq.X)
     cirq.testing.assert_has_consistent_apply_unitary(cirq.Y)
     cirq.testing.assert_has_consistent_apply_unitary(cirq.Z)
 
 
-def test_identity_multiplication():
+def test_identity_multiplication() -> None:
     a, b, c = cirq.LineQubit.range(3)
     assert cirq.X(a) * cirq.I(a) == cirq.X(a)
     assert cirq.X(a) * cirq.I(b) == cirq.X(a)
@@ -207,7 +209,7 @@ def test_identity_multiplication():
         _ = cirq.I(a) * str(cirq.Y(b))
 
 
-def test_powers():
+def test_powers() -> None:
     assert isinstance(cirq.X, cirq.Pauli)
     assert isinstance(cirq.Y, cirq.Pauli)
     assert isinstance(cirq.Z, cirq.Pauli)
@@ -221,3 +223,10 @@ def test_powers():
     assert isinstance(cirq.X**1, cirq.Pauli)
     assert isinstance(cirq.Y**1, cirq.Pauli)
     assert isinstance(cirq.Z**1, cirq.Pauli)
+
+    with pytest.raises(TypeError, match="Gate exponent must be a number or sympy expression."):
+        assert cirq.X ** 'text'
+    with pytest.raises(TypeError, match="Gate exponent must be a number or sympy expression."):
+        assert cirq.Y ** 'text'
+    with pytest.raises(TypeError, match="Gate exponent must be a number or sympy expression."):
+        assert cirq.Z ** 'text'

cirq/ops/pauli_interaction_gate.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Iterator, List, Sequence, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Any, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -24,7 +26,7 @@ from cirq.ops.clifford_gate import SingleQubitCliffordGate
 if TYPE_CHECKING:
     import cirq
 
-PAULI_EIGEN_MAP: Dict[pauli_gates.Pauli, Tuple[np.ndarray, np.ndarray]] = {
+PAULI_EIGEN_MAP: dict[pauli_gates.Pauli, tuple[np.ndarray, np.ndarray]] = {
     pauli_gates.X: (np.array([[0.5, 0.5], [0.5, 0.5]]), np.array([[0.5, -0.5], [-0.5, 0.5]])),
     pauli_gates.Y: (np.array([[0.5, -0.5j], [0.5j, 0.5]]), np.array([[0.5, 0.5j], [-0.5j, 0.5]])),
     pauli_gates.Z: (np.diag([1, 0]), np.diag([0, 1])),
@@ -35,8 +37,8 @@ PAULI_EIGEN_MAP: Dict[pauli_gates.Pauli, Tuple[np.ndarray, np.ndarray]] = {
 class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate):
     """A CZ conjugated by arbitrary single qubit Cliffords."""
 
-    CZ: 'PauliInteractionGate'
-    CNOT: 'PauliInteractionGate'
+    CZ: PauliInteractionGate
+    CNOT: PauliInteractionGate
 
     def __init__(
         self,
@@ -66,7 +68,7 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
         self._invert1 = invert1
 
     @property
-    def pauli0(self) -> 'cirq.Pauli':
+    def pauli0(self) -> cirq.Pauli:
         return self._pauli0
 
     @property
@@ -74,7 +76,7 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
         return self._invert0
 
     @property
-    def pauli1(self) -> 'cirq.Pauli':
+    def pauli1(self) -> cirq.Pauli:
         return self._pauli1
 
     @property
@@ -98,15 +100,15 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
             return 0
         return index
 
-    def _with_exponent(self, exponent: value.TParamVal) -> 'PauliInteractionGate':
+    def _with_exponent(self, exponent: value.TParamVal) -> PauliInteractionGate:
         return PauliInteractionGate(
             self.pauli0, self.invert0, self.pauli1, self.invert1, exponent=exponent
         )
 
-    def _eigen_shifts(self) -> List[float]:
+    def _eigen_shifts(self) -> list[float]:
         return [0.0, 1.0]
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         comp1 = np.kron(
             PAULI_EIGEN_MAP[self.pauli0][not self.invert0],
             PAULI_EIGEN_MAP[self.pauli1][not self.invert1],
@@ -114,7 +116,7 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
         comp0 = np.eye(4) - comp1
         return [(0, comp0), (1, comp1)]
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         q0, q1 = qubits
         right_gate0 = SingleQubitCliffordGate.from_single_map(z_to=(self.pauli0, self.invert0))
         right_gate1 = SingleQubitCliffordGate.from_single_map(z_to=(self.pauli1, self.invert1))
@@ -127,14 +129,8 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
         yield right_gate0(q0)
         yield right_gate1(q1)
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
-        labels: Dict['cirq.Pauli', str] = {
-            pauli_gates.X: 'X',
-            pauli_gates.Y: 'Y',
-            pauli_gates.Z: '@',
-        }
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
+        labels: dict[cirq.Pauli, str] = {pauli_gates.X: 'X', pauli_gates.Y: 'Y', pauli_gates.Z: '@'}
         l0 = labels[self.pauli0]
         l1 = labels[self.pauli1]
         # Add brackets around letter if inverted
@@ -153,7 +149,7 @@ class PauliInteractionGate(gate_features.InterchangeableQubitsGate, eigen_gate.E
             return base
         return f'({base}**{proper_repr(self._exponent)})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ["pauli0", "invert0", "pauli1", "invert1"])