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

cirq/ops/raw_types_test.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import AbstractSet, Any, Iterator
+from __future__ import annotations
+
+from typing import AbstractSet, Any, cast, Iterator
 
 import numpy as np
 import pytest
@@ -26,7 +28,7 @@ class ValidQubit(cirq.Qid):
         self._name = name
 
     @property
-    def dimension(self):
+    def dimension(self) -> int:
         return 2
 
     def _comparison_key(self):
@@ -49,19 +51,19 @@ class ValidQid(cirq.Qid):
     def dimension(self):
         return self._dimension
 
-    def with_dimension(self, dimension):
+    def with_dimension(self, dimension) -> ValidQid:
         return ValidQid(self._name, dimension)
 
     def _comparison_key(self):
         return self._name
 
 
-def test_wrapped_qid():
+def test_wrapped_qid() -> None:
     assert type(ValidQubit('a').with_dimension(3)) is not ValidQubit
     assert type(ValidQubit('a').with_dimension(2)) is ValidQubit
     assert type(ValidQubit('a').with_dimension(5).with_dimension(2)) is ValidQubit
     assert ValidQubit('a').with_dimension(3).with_dimension(4) == ValidQubit('a').with_dimension(4)
-    assert ValidQubit('a').with_dimension(3).qubit == ValidQubit('a')
+    assert ValidQubit('a').with_dimension(3).qubit == ValidQubit('a')  # type: ignore[attr-defined]
     assert ValidQubit('a').with_dimension(3) == ValidQubit('a').with_dimension(3)
     assert ValidQubit('a').with_dimension(3) < ValidQubit('a').with_dimension(4)
     assert ValidQubit('a').with_dimension(3) < ValidQubit('b').with_dimension(3)
@@ -72,12 +74,12 @@ def test_wrapped_qid():
     )
     assert str(ValidQubit('a').with_dimension(3)) == 'TQ_a (d=3)'
 
-    assert ValidQubit('zz').with_dimension(3)._json_dict_() == {
+    assert ValidQubit('zz').with_dimension(3)._json_dict_() == {  # type: ignore[attr-defined]
         'qubit': ValidQubit('zz'),
         'dimension': 3,
     }
 
-    assert not ValidQubit('zz') == 4
+    assert not ValidQubit('zz') == 4  # noqa: SIM201
     assert ValidQubit('zz') != 4
     assert ValidQubit('zz') > ValidQubit('aa')
     assert ValidQubit('zz') <= ValidQubit('zz')
@@ -85,7 +87,7 @@ def test_wrapped_qid():
     assert ValidQubit('zz') >= ValidQubit('aa')
 
 
-def test_qid_dimension():
+def test_qid_dimension() -> None:
     assert ValidQubit('a').dimension == 2
     assert ValidQubit('a').with_dimension(3).dimension == 3
     with pytest.raises(ValueError, match='Wrong qid dimension'):
@@ -106,7 +108,7 @@ class ValiGate(cirq.Gate):
     def _num_qubits_(self):
         return 2
 
-    def validate_args(self, qubits):
+    def validate_args(self, qubits) -> None:
         if len(qubits) == 1:
             return  # Bypass check for some tests
         super().validate_args(qubits)
@@ -115,7 +117,7 @@ class ValiGate(cirq.Gate):
         return True
 
 
-def test_gate():
+def test_gate() -> None:
     a, b, c = cirq.LineQubit.range(3)
 
     g = ValiGate()
@@ -135,7 +137,7 @@ def test_gate():
     assert g.controlled(0) is g
 
 
-def test_op():
+def test_op() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     g = ValiGate()
     op = g(a, b)
@@ -145,7 +147,7 @@ def test_op():
     assert controlled_op.controls == (c, d)
 
 
-def test_op_validate():
+def test_op_validate() -> None:
     op = cirq.X(cirq.LineQid(0, 2))
     op2 = cirq.CNOT(*cirq.LineQid.range(2, dimension=2))
     op.validate_args([cirq.LineQid(1, 2)])  # Valid
@@ -158,7 +160,7 @@ def test_op_validate():
         op2.validate_args([cirq.LineQid(1, 2), cirq.LineQid(1, 2)])
 
 
-def test_disable_op_validation():
+def test_disable_op_validation() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     h_op = cirq.H(q0)
 
@@ -181,7 +183,7 @@ def test_disable_op_validation():
         h_op.validate_args([q0, q1])
 
 
-def test_default_validation_and_inverse():
+def test_default_validation_and_inverse() -> None:
     class TestGate(cirq.Gate):
         def _num_qubits_(self):
             return 2
@@ -203,13 +205,15 @@ def test_default_validation_and_inverse():
     with pytest.raises(ValueError, match='number of qubits'):
         TestGate().on(a)
 
-    t = TestGate().on(a, b)
-    i = t**-1
+    t = cast(cirq.GateOperation, TestGate().on(a, b))
+    i = cast(cirq.GateOperation, t**-1)
     assert i**-1 == t
     assert t**-1 == i
     assert cirq.decompose(i) == [cirq.X(a), cirq.S(b) ** -1, cirq.Z(a)]
-    assert [*i._decompose_()] == [cirq.X(a), cirq.S(b) ** -1, cirq.Z(a)]
-    assert [*i.gate._decompose_([a, b])] == [cirq.X(a), cirq.S(b) ** -1, cirq.Z(a)]
+    assert [*i._decompose_()] == [cirq.X(a), cirq.S(b) ** -1, cirq.Z(a)]  # type: ignore[misc]
+    gate = i.gate
+    assert gate is not None
+    assert [*gate._decompose_([a, b])] == [cirq.X(a), cirq.S(b) ** -1, cirq.Z(a)]  # type: ignore
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.unitary(i), cirq.unitary(t).conj().T, atol=1e-8
     )
@@ -217,7 +221,7 @@ def test_default_validation_and_inverse():
     cirq.testing.assert_implements_consistent_protocols(i, local_vals={'TestGate': TestGate})
 
 
-def test_default_no_qubits():
+def test_default_no_qubits() -> None:
     class TestOp(cirq.Operation):
         def with_qubits(self, *new_qubits):
             raise NotImplementedError()
@@ -228,11 +232,11 @@ def test_default_no_qubits():
 
     op = TestOp()
     assert op.controlled_by(*[]) is op
-    op = TestOp().with_tags("abc")
-    assert op.classical_controls == frozenset()
+    tagged_op = TestOp().with_tags("abc")
+    assert tagged_op.classical_controls == frozenset()
 
 
-def test_default_inverse():
+def test_default_inverse() -> None:
     class TestGate(cirq.Gate):
         def _num_qubits_(self):
             return 3
@@ -247,7 +251,7 @@ def test_default_inverse():
     )
 
 
-def test_no_inverse_if_not_unitary():
+def test_no_inverse_if_not_unitary() -> None:
     class TestGate(cirq.Gate):
         def _num_qubits_(self):
             return 1
@@ -258,7 +262,7 @@ def test_no_inverse_if_not_unitary():
     assert cirq.inverse(TestGate(), None) is None
 
 
-def test_default_qudit_inverse():
+def test_default_qudit_inverse() -> None:
     class TestGate(cirq.Gate):
         def _qid_shape_(self):
             return (1, 2, 3)
@@ -283,11 +287,11 @@ def test_default_qudit_inverse():
         (-cirq.X * sympy.Symbol('s'), -sympy.Symbol('s') * cirq.X),
     ),
 )
-def test_gate_algebra(expression, expected_result):
+def test_gate_algebra(expression, expected_result) -> None:
     assert expression == expected_result
 
 
-def test_gate_shape():
+def test_gate_shape() -> None:
     class ShapeGate(cirq.Gate):
         def _qid_shape_(self):
             return (1, 2, 3, 4)
@@ -316,7 +320,7 @@ def test_gate_shape():
     assert dep_gate.num_qubits() == 3
 
 
-def test_gate_shape_protocol():
+def test_gate_shape_protocol() -> None:
     """This test is only needed while the `_num_qubits_` and `_qid_shape_`
     methods are implemented as alternatives.  This can be removed once the
     deprecated `num_qubits` method is removed."""
@@ -376,7 +380,7 @@ def test_gate_shape_protocol():
     assert QubitGate().num_qubits() == 2  # Deprecated
 
 
-def test_operation_shape():
+def test_operation_shape() -> None:
     class FixedQids(cirq.Operation):
         def with_qubits(self, *new_qids):
             raise NotImplementedError
@@ -418,12 +422,12 @@ def test_operation_shape():
     assert cirq.num_qubits(shape_op) == 4
 
 
-def test_gate_json_dict():
+def test_gate_json_dict() -> None:
     g = cirq.CSWAP  # not an eigen gate (which has its own _json_dict_)
     assert g._json_dict_() == {}
 
 
-def test_inverse_composite_diagram_info():
+def test_inverse_composite_diagram_info() -> None:
     class Gate(cirq.Gate):
         def _decompose_(self, qubits):
             return cirq.S.on(qubits[0])
@@ -450,7 +454,7 @@ def test_inverse_composite_diagram_info():
     )
 
 
-def test_tagged_operation_equality():
+def test_tagged_operation_equality() -> None:
     eq = cirq.testing.EqualsTester()
     q1 = cirq.GridQubit(1, 1)
     op = cirq.X(q1)
@@ -467,7 +471,7 @@ def test_tagged_operation_equality():
     )
 
 
-def test_tagged_operation():
+def test_tagged_operation() -> None:
     q1 = cirq.GridQubit(1, 1)
     q2 = cirq.GridQubit(2, 2)
     op = cirq.X(q1).with_tags('tag1')
@@ -488,7 +492,7 @@ def test_tagged_operation():
         _ = cirq.X(q1).with_tags(cirq.Circuit)
 
 
-def test_with_tags_returns_same_instance_if_possible():
+def test_with_tags_returns_same_instance_if_possible() -> None:
     untagged = cirq.X(cirq.GridQubit(1, 1))
     assert untagged.with_tags() is untagged
 
@@ -496,7 +500,7 @@ def test_with_tags_returns_same_instance_if_possible():
     assert tagged.with_tags() is tagged
 
 
-def test_tagged_measurement():
+def test_tagged_measurement() -> None:
     assert not cirq.is_measurement(cirq.global_phase_operation(coefficient=-1.0).with_tags('tag0'))
 
     a = cirq.LineQubit(0)
@@ -510,14 +514,14 @@ def test_tagged_measurement():
     assert cirq.with_measurement_key_mapping(op, {'x': 'k'}) == op
 
 
-def test_cannot_remap_non_measurement_gate():
+def test_cannot_remap_non_measurement_gate() -> None:
     a = cirq.LineQubit(0)
     op = cirq.X(a).with_tags('tag')
 
     assert cirq.with_measurement_key_mapping(op, {'m': 'k'}) is NotImplemented
 
 
-def test_circuit_diagram():
+def test_circuit_diagram() -> None:
     class TaggyTag:
         """Tag with a custom str function to test circuit diagrams."""
 
@@ -535,7 +539,7 @@ def test_circuit_diagram():
         exponent_qubit_index=None,
         auto_exponent_parens=True,
     )
-    args = cirq.CircuitDiagramInfoArgs(None, None, None, None, None, False)
+    args = cirq.CircuitDiagramInfoArgs(None, None, False, None, None, False)
     assert cirq.circuit_diagram_info(tagged_h) == expected
     assert cirq.circuit_diagram_info(tagged_h, args) == cirq.circuit_diagram_info(h)
 
@@ -550,9 +554,11 @@ def test_circuit_diagram():
     diagram_with_non_string_tag = "(1, 1): ───H[<taggy>]───"
     assert c.to_text_diagram() == diagram_with_non_string_tag
     assert c.to_text_diagram(include_tags=False) == diagram_without_tags
+    assert c.to_text_diagram(include_tags={str}) == diagram_without_tags
+    assert c.to_text_diagram(include_tags={TaggyTag}) == diagram_with_non_string_tag
 
 
-def test_circuit_diagram_tagged_global_phase():
+def test_circuit_diagram_tagged_global_phase() -> None:
     # Tests global phase operation
     q = cirq.NamedQubit('a')
     global_phase = cirq.global_phase_operation(coefficient=-1.0).with_tags('tag0')
@@ -580,8 +586,8 @@ def test_circuit_diagram_tagged_global_phase():
     # Operation with no qubits and returns diagram info with no wire symbols
     class NoWireSymbols(cirq.GlobalPhaseGate):
         def _circuit_diagram_info_(
-            self, args: 'cirq.CircuitDiagramInfoArgs'
-        ) -> 'cirq.CircuitDiagramInfo':
+            self, args: cirq.CircuitDiagramInfoArgs
+        ) -> cirq.CircuitDiagramInfo:
             return expected
 
     no_wire_symbol_op = NoWireSymbols(coefficient=-1.0)().with_tags('tag0')
@@ -619,7 +625,7 @@ global phase:   0.5π[tag1]   0.5π[tag2]
     )
 
 
-def test_circuit_diagram_no_circuit_diagram():
+def test_circuit_diagram_no_circuit_diagram() -> None:
     class NoCircuitDiagram(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -634,7 +640,7 @@ def test_circuit_diagram_no_circuit_diagram():
     assert cirq.Circuit(NoCircuitDiagram()(q).with_tags('taggy')).to_text_diagram() == expected
 
 
-def test_tagged_operation_forwards_protocols():
+def test_tagged_operation_forwards_protocols() -> None:
     """The results of all protocols applied to an operation with a tag should
     be equivalent to the result without tags.
     """
@@ -647,7 +653,7 @@ def test_tagged_operation_forwards_protocols():
     np.testing.assert_equal(cirq.unitary(tagged_h), cirq.unitary(h))
     assert cirq.has_unitary(tagged_h)
     assert cirq.decompose(tagged_h) == cirq.decompose(h)
-    assert [*tagged_h._decompose_()] == cirq.decompose(h)
+    assert [*tagged_h._decompose_()] == cirq.decompose_once(h)
     assert cirq.pauli_expansion(tagged_h) == cirq.pauli_expansion(h)
     assert cirq.equal_up_to_global_phase(h, tagged_h)
     assert np.isclose(cirq.kraus(h), cirq.kraus(tagged_h)).all()
@@ -716,7 +722,7 @@ def test_tagged_operation_forwards_protocols():
     assert tagged_mixture[1][0] == flip_mixture[1][0]
     assert np.isclose(tagged_mixture[1][1], flip_mixture[1][1]).all()
 
-    qubit_map = {q1: 'q1'}
+    qubit_map: dict[cirq.Qid, str] = {q1: 'q1'}
     qasm_args = cirq.QasmArgs(qubit_id_map=qubit_map)
     assert cirq.qasm(h, args=qasm_args) == cirq.qasm(tagged_h, args=qasm_args)
 
@@ -737,13 +743,13 @@ class ParameterizableTag:
         return cirq.parameter_names(self.value)
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'ParameterizableTag':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> ParameterizableTag:
         return ParameterizableTag(cirq.resolve_parameters(self.value, resolver, recursive))
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_tagged_operation_resolves_parameterized_tags(resolve_fn):
+def test_tagged_operation_resolves_parameterized_tags(resolve_fn) -> None:
     q = cirq.GridQubit(0, 0)
     tag = ParameterizableTag(sympy.Symbol('t'))
     assert cirq.is_parameterized(tag)
@@ -757,10 +763,10 @@ def test_tagged_operation_resolves_parameterized_tags(resolve_fn):
     assert cirq.parameter_names(resolved_op) == set()
 
 
-def test_inverse_composite_standards():
+def test_inverse_composite_standards() -> None:
     @cirq.value_equality
     class Gate(cirq.Gate):
-        def __init__(self, param: 'cirq.TParamVal'):
+        def __init__(self, param: cirq.TParamVal):
             self._param = param
 
         def _decompose_(self, qubits):
@@ -781,7 +787,7 @@ def test_inverse_composite_standards():
         def _is_parameterized_(self) -> bool:
             return cirq.is_parameterized(self._param)
 
-        def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> 'Gate':
+        def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> Gate:
             return Gate(cirq.resolve_parameters(self._param, resolver, recursive))
 
         def __repr__(self):
@@ -796,7 +802,7 @@ def test_inverse_composite_standards():
     assert str(g) == 'C(a)†'
 
 
-def test_tagged_act_on():
+def test_tagged_act_on() -> None:
     class YesActOn(cirq.Gate):
         def _num_qubits_(self) -> int:
             return 1
@@ -830,7 +836,7 @@ def test_tagged_act_on():
         cirq.act_on(MissingActOn().with_tags("test"), args)
 
 
-def test_single_qubit_gate_validates_on_each():
+def test_single_qubit_gate_validates_on_each() -> None:
     class Example(cirq.testing.SingleQubitGate):
         def matrix(self):
             pass
@@ -854,7 +860,7 @@ def test_single_qubit_gate_validates_on_each():
         _ = g.on_each(*test_non_qubits)
 
 
-def test_on_each():
+def test_on_each() -> None:
     class CustomGate(cirq.testing.SingleQubitGate):
         pass
 
@@ -885,7 +891,7 @@ def test_on_each():
     assert c.on_each(qubit_iterator) == [c(a), c(b), c(a), c(b)]
 
 
-def test_on_each_two_qubits():
+def test_on_each_two_qubits() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     g = cirq.testing.TwoQubitGate()
@@ -940,7 +946,7 @@ def test_on_each_two_qubits():
     assert g.on_each(qubit_iterator) == [g(a, b), g(a, b)]
 
 
-def test_on_each_three_qubits():
+def test_on_each_three_qubits() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -990,7 +996,7 @@ def test_on_each_three_qubits():
     assert g.on_each(qubit_iterator) == [g(a, b, c), g(a, b, c)]
 
 
-def test_on_each_iterable_qid():
+def test_on_each_iterable_qid() -> None:
     class QidIter(cirq.Qid):
         @property
         def dimension(self) -> int:
@@ -1008,7 +1014,7 @@ def test_on_each_iterable_qid():
 @pytest.mark.parametrize(
     'op', [cirq.X(cirq.NamedQubit("q")), cirq.X(cirq.NamedQubit("q")).with_tags("tagged_op")]
 )
-def test_with_methods_return_self_on_empty_conditions(op):
+def test_with_methods_return_self_on_empty_conditions(op) -> None:
     assert op is op.with_tags(*[])
     assert op is op.with_classical_controls(*[])
     assert op is op.controlled_by(*[])

cirq/ops/state_preparation_channel.py

@@ -14,7 +14,9 @@
 
 """Quantum gates to prepare a given target state."""
 
-from typing import Any, Dict, Iterable, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Any, Iterable, TYPE_CHECKING
 
 import numpy as np
 
@@ -57,14 +59,14 @@ class StatePreparationChannel(raw_types.Gate):
         it involves measurement."""
         return False
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         """Converts the gate object into a serializable dictionary"""
         return {'target_state': self._state.tolist(), 'name': self._name}
 
     @classmethod
     def _from_json_dict_(
         cls, target_state: np.ndarray, name: str, **kwargs
-    ) -> 'StatePreparationChannel':
+    ) -> StatePreparationChannel:
         """Recreates the channel object from it's serialized form
 
         Args:
@@ -77,12 +79,10 @@ class StatePreparationChannel(raw_types.Gate):
     def _num_qubits_(self) -> int:
         return self._num_qubits
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return self._qid_shape
 
-    def _circuit_diagram_info_(
-        self, _args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, _args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         """Returns the information required to draw out the circuit diagram for this channel."""
         symbols = (
             [self._name]

cirq/ops/state_preparation_channel_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 numpy as np
 import pytest
 
@@ -36,7 +38,7 @@ import cirq
         ]
     ),
 )
-def test_state_prep_channel_kraus(state):
+def test_state_prep_channel_kraus(state) -> None:
     qubits = cirq.LineQubit.range(2)
     gate = cirq.StatePreparationChannel(state)(qubits[0], qubits[1])
     cirq.testing.assert_consistent_channel(gate)
@@ -53,7 +55,7 @@ def test_state_prep_channel_kraus(state):
     )
 
 
-def test_state_prep_channel_kraus_small():
+def test_state_prep_channel_kraus_small() -> None:
     gate = cirq.StatePreparationChannel(np.array([0.0, 1.0]))(cirq.LineQubit(0))
     np.testing.assert_almost_equal(
         cirq.kraus(gate), (np.array([[0.0, 0.0], [1.0, 0.0]]), np.array([[0.0, 0.0], [0.0, 1.0]]))
@@ -69,7 +71,7 @@ def test_state_prep_channel_kraus_small():
     assert not cirq.has_mixture(gate)
 
 
-def test_state_prep_gate_printing():
+def test_state_prep_gate_printing() -> None:
     circuit = cirq.Circuit()
     qubits = cirq.LineQubit.range(2)
     gate = cirq.StatePreparationChannel(np.array([1, 0, 0, 1]) / np.sqrt(2))
@@ -87,7 +89,7 @@ def test_state_prep_gate_printing():
 
 
 @pytest.mark.parametrize('name', ['Prep', 'S'])
-def test_state_prep_gate_printing_with_name(name):
+def test_state_prep_gate_printing_with_name(name) -> None:
     circuit = cirq.Circuit()
     qubits = cirq.LineQubit.range(2)
     gate = cirq.StatePreparationChannel(np.array([1, 0, 0, 1]) / np.sqrt(2), name=name)
@@ -104,7 +106,7 @@ def test_state_prep_gate_printing_with_name(name):
     )
 
 
-def test_gate_params():
+def test_gate_params() -> None:
     state = np.array([1, 0, 0, 0], dtype=np.complex64)
     gate = cirq.StatePreparationChannel(state)
     assert gate.num_qubits() == 2
@@ -114,19 +116,19 @@ def test_gate_params():
     cirq.testing.assert_equivalent_repr(gate)
 
 
-def test_gate_error_handling():
+def test_gate_error_handling() -> None:
     with pytest.raises(ValueError, match='`target_state` must be a 1d numpy array.'):
         cirq.StatePreparationChannel(np.eye(2))
     with pytest.raises(ValueError, match='Matrix width \\(5\\) is not a power of 2'):
         cirq.StatePreparationChannel(np.ones(shape=5))
 
 
-def test_equality_of_gates():
+def test_equality_of_gates() -> None:
     state = np.array([1, 0, 0, 0], dtype=np.complex64)
     gate_1 = cirq.StatePreparationChannel(state)
     gate_2 = cirq.StatePreparationChannel(state)
     assert gate_1 == gate_2, "Equal state not leading to same gate"
-    assert not gate_1 == state, "Incompatible objects shouldn't be equal"
+    assert not gate_1 == state, "Incompatible objects shouldn't be equal"  # noqa: SIM201
     state = np.array([0, 1, 0, 0], dtype=np.complex64)
     gate_3 = cirq.StatePreparationChannel(state, name='gate_a')
     gate_4 = cirq.StatePreparationChannel(state, name='gate_b')
@@ -134,7 +136,7 @@ def test_equality_of_gates():
     assert gate_1 != gate_3, "Different states shouldn't lead to same gate"
 
 
-def test_approx_equality_of_gates():
+def test_approx_equality_of_gates() -> None:
     state = np.array([1, 0, 0, 0], dtype=np.complex64)
     gate_1 = cirq.StatePreparationChannel(state)
     gate_2 = cirq.StatePreparationChannel(state)

cirq/ops/swap_gates.py

@@ -25,7 +25,9 @@ raised to a power (i.e. SQRT_ISWAP_INV=cirq.ISWAP**-0.5). See the definition in
 EigenGate.
 """
 
-from typing import cast, List, Optional, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import cast, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -81,7 +83,7 @@ class SwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate)
         )
         yield common_gates.CNOT(a, b)
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         # yapf: disable
         return [
             (0, np.array([[1, 0,   0,   0],
@@ -95,17 +97,17 @@ class SwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate)
         ]
         # yapf: enable
 
-    def _trace_distance_bound_(self) -> Optional[float]:
+    def _trace_distance_bound_(self) -> float | None:
         if self._is_parameterized_():
             return None
         return abs(np.sin(self._exponent * 0.5 * np.pi))
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         if self._is_parameterized_():
             return None
         return self.exponent % 1 == 0
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray | None:
         if self._exponent != 1:
             return NotImplemented
 
@@ -134,9 +136,7 @@ class SwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate)
             }
         )
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         if not args.use_unicode_characters:
             return protocols.CircuitDiagramInfo(
                 wire_symbols=('Swap', 'Swap'), exponent=self._diagram_exponent(args)
@@ -145,7 +145,7 @@ class SwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate)
             wire_symbols=('×', '×'), exponent=self._diagram_exponent(args)
         )
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         if self._exponent != 1:
             return None  # Don't have an equivalent gate in QASM
         args.validate_version('2.0', '3.0')
@@ -204,7 +204,7 @@ class ISwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate
     def _num_qubits_(self) -> int:
         return 2
 
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         # yapf: disable
         return [
             (0, np.diag([1, 0, 0, 1])),
@@ -219,7 +219,7 @@ class ISwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate
         ]
         # yapf: enable
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         if self._is_parameterized_():
             return None
         return self.exponent % 1 == 0
@@ -240,7 +240,7 @@ class ISwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate
         yield common_gates.H(a)
         yield common_gates.CNOT(a, b)
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> Optional[np.ndarray]:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray | None:
         if self._exponent != 1:
             return NotImplemented
 
@@ -271,9 +271,7 @@ class ISwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate
             }
         )
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(
             wire_symbols=('iSwap', 'iSwap'), exponent=self._diagram_exponent(args)
         )