cirq-core 1.6.0.dev20250529190313__py3-none-any.whl → 1.6.0.dev20250530174306__py3-none-any.whl

cirq/ops/identity_test.py

@@ -26,7 +26,7 @@ import cirq
 
 
 @pytest.mark.parametrize('num_qubits', [1, 2, 4])
-def test_identity_init(num_qubits):
+def test_identity_init(num_qubits) -> None:
     assert cirq.IdentityGate(num_qubits).num_qubits() == num_qubits
     assert cirq.qid_shape(cirq.IdentityGate(num_qubits)) == (2,) * num_qubits
     assert cirq.qid_shape(cirq.IdentityGate(3, (1, 2, 3))) == (1, 2, 3)
@@ -37,7 +37,7 @@ def test_identity_init(num_qubits):
         cirq.IdentityGate()
 
 
-def test_identity_on_each():
+def test_identity_on_each() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     assert cirq.I.on_each(q0, q1, q2) == [cirq.I(q0), cirq.I(q1), cirq.I(q2)]
     assert cirq.I.on_each([q0, [q1], q2]) == [cirq.I(q0), cirq.I(q1), cirq.I(q2)]
@@ -46,7 +46,7 @@ def test_identity_on_each():
         cirq.I.on_each('abc')
 
 
-def test_identity_on_each_iter_second():
+def test_identity_on_each_iter_second() -> None:
     class Q(cirq.Qid):
         @property
         def dimension(self) -> int:
@@ -63,7 +63,7 @@ def test_identity_on_each_iter_second():
     assert cirq.I.on_each(q) == [cirq.I(q)]
 
 
-def test_identity_on_each_only_single_qubit():
+def test_identity_on_each_only_single_qubit() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     q0_3, q1_3 = q0.with_dimension(3), q1.with_dimension(3)
     assert cirq.I.on_each(q0, q1) == [cirq.I.on(q0), cirq.I.on(q1)]
@@ -73,7 +73,7 @@ def test_identity_on_each_only_single_qubit():
     ]
 
 
-def test_identity_on_each_two_qubits():
+def test_identity_on_each_two_qubits() -> None:
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     q0_3, q1_3 = q0.with_dimension(3), q1.with_dimension(3)
     assert cirq.IdentityGate(2).on_each([(q0, q1)]) == [cirq.IdentityGate(2)(q0, q1)]
@@ -96,14 +96,14 @@ def test_identity_on_each_two_qubits():
 
 
 @pytest.mark.parametrize('num_qubits', [1, 2, 4])
-def test_identity_unitary(num_qubits):
+def test_identity_unitary(num_qubits) -> None:
     i = cirq.IdentityGate(num_qubits)
     assert np.allclose(cirq.unitary(i), np.identity(2**num_qubits))
     i3 = cirq.IdentityGate(num_qubits, (3,) * num_qubits)
     assert np.allclose(cirq.unitary(i3), np.identity(3**num_qubits))
 
 
-def test_identity_str():
+def test_identity_str() -> None:
     assert str(cirq.IdentityGate(1)) == 'I'
     assert str(cirq.IdentityGate(2)) == 'I(2)'
     # Qid shape is not included in str
@@ -111,13 +111,13 @@ def test_identity_str():
     assert str(cirq.IdentityGate(2, (1, 2))) == 'I(2)'
 
 
-def test_identity_repr():
+def test_identity_repr() -> None:
     assert repr(cirq.I) == 'cirq.I'
     assert repr(cirq.IdentityGate(5)) == 'cirq.IdentityGate(5)'
     assert repr(cirq.IdentityGate(qid_shape=(2, 3))) == 'cirq.IdentityGate(qid_shape=(2, 3))'
 
 
-def test_identity_apply_unitary():
+def test_identity_apply_unitary() -> None:
     v = np.array([1, 0])
     result = cirq.apply_unitary(cirq.I, cirq.ApplyUnitaryArgs(v, np.array([0, 1]), (0,)))
     assert result is v
@@ -129,7 +129,7 @@ def test_identity_apply_unitary():
     assert result is v
 
 
-def test_identity_eq():
+def test_identity_eq() -> None:
     equals_tester = cirq.testing.EqualsTester()
     equals_tester.make_equality_group(
         lambda: cirq.I, lambda: cirq.IdentityGate(1), lambda: cirq.IdentityGate(1, (2,))
@@ -140,12 +140,12 @@ def test_identity_eq():
     equals_tester.add_equality_group(cirq.IdentityGate(4, (1, 2, 3, 4)))
 
 
-def test_identity_trace_distance_bound():
+def test_identity_trace_distance_bound() -> None:
     assert cirq.I._trace_distance_bound_() == 0
     assert cirq.IdentityGate(num_qubits=2)._trace_distance_bound_() == 0
 
 
-def test_identity_pow():
+def test_identity_pow() -> None:
     I = cirq.I
     q = cirq.NamedQubit('q')
 
@@ -159,28 +159,29 @@ def test_identity_pow():
         _ = I(q) ** q
 
 
-def test_pauli_expansion_notimplemented():
+def test_pauli_expansion_notimplemented() -> None:
     assert cirq.IdentityGate(1, (3,))._pauli_expansion_() == NotImplemented
 
 
 @pytest.mark.parametrize(
     'gate_type, num_qubits', itertools.product((cirq.IdentityGate,), range(1, 5))
 )
-def test_consistent_protocols(gate_type, num_qubits):
+def test_consistent_protocols(gate_type, num_qubits) -> None:
     gate = gate_type(num_qubits=num_qubits)
     cirq.testing.assert_implements_consistent_protocols(gate, qubit_count=num_qubits)
 
 
-def test_identity_global():
+def test_identity_global() -> None:
     qubits = cirq.LineQubit.range(3)
     assert cirq.identity_each(*qubits) == cirq.IdentityGate(3).on(*qubits)
     qids = cirq.LineQid.for_qid_shape((1, 2, 3))
     assert cirq.identity_each(*qids) == cirq.IdentityGate(3, (1, 2, 3)).on(*qids)
     with pytest.raises(ValueError, match='Not a cirq.Qid'):
-        cirq.identity_each(qubits)  # The user forgot to expand the list for example.
+        # The user forgot to expand the list for example.
+        cirq.identity_each(qubits)  # type: ignore[arg-type]
 
 
-def test_identity_mul():
+def test_identity_mul() -> None:
     class UnknownGate(cirq.testing.SingleQubitGate):
         pass
 
@@ -207,19 +208,19 @@ def test_identity_mul():
     assert 1j * i == cirq.PauliString(coefficient=1j)
 
 
-def test_identity_short_circuits_act_on():
+def test_identity_short_circuits_act_on() -> None:
     args = mock.Mock(cirq.SimulationState)
     args._act_on_fallback_.side_effect = mock.Mock(side_effect=Exception('No!'))
     cirq.act_on(cirq.IdentityGate(1)(cirq.LineQubit(0)), args)
 
 
-def test_identity_commutes():
+def test_identity_commutes() -> None:
     assert cirq.commutes(cirq.I, cirq.X)
     with pytest.raises(TypeError):
         cirq.commutes(cirq.I, "Gate")
 
 
-def test_identity_diagram():
+def test_identity_diagram() -> None:
     cirq.testing.assert_has_diagram(
         cirq.Circuit(cirq.IdentityGate(3).on_each(cirq.LineQubit.range(3))),
         """

cirq/ops/kraus_channel_test.py

@@ -8,7 +8,7 @@ import pytest
 import cirq
 
 
-def test_kraus_channel_from_channel():
+def test_kraus_channel_from_channel() -> None:
     q0 = cirq.LineQubit(0)
     dp = cirq.depolarize(0.1)
     kc = cirq.KrausChannel.from_channel(dp, key='dp')
@@ -24,7 +24,7 @@ def test_kraus_channel_from_channel():
     assert results.measurements['dp'] in range(4)
 
 
-def test_kraus_channel_equality():
+def test_kraus_channel_equality() -> None:
     dp_pt1 = cirq.depolarize(0.1)
     dp_pt2 = cirq.depolarize(0.2)
     kc_a1 = cirq.KrausChannel.from_channel(dp_pt1, key='a')
@@ -47,7 +47,7 @@ def test_kraus_channel_equality():
     assert x_meas != x_meas_inv
 
 
-def test_kraus_channel_remap_keys():
+def test_kraus_channel_remap_keys() -> None:
     dp = cirq.depolarize(0.1)
     kc = cirq.KrausChannel.from_channel(dp)
     with pytest.raises(TypeError):
@@ -65,7 +65,7 @@ def test_kraus_channel_remap_keys():
     assert cirq.with_measurement_key_mapping(kc_a, {'a': 'b'}) == kc_b
 
 
-def test_kraus_channel_from_kraus():
+def test_kraus_channel_from_kraus() -> None:
     q0 = cirq.LineQubit(0)
     # This is equivalent to an X-basis measurement.
     ops = [np.array([[1, 1], [1, 1]]) * 0.5, np.array([[1, -1], [-1, 1]]) * 0.5]
@@ -80,7 +80,7 @@ def test_kraus_channel_from_kraus():
     assert results.measurements['x_meas'] == 0
 
 
-def test_kraus_channel_str():
+def test_kraus_channel_str() -> None:
     # This is equivalent to an X-basis measurement.
     ops = [np.array([[1, 1], [1, 1]]) * 0.5, np.array([[1, -1], [-1, 1]]) * 0.5]
     x_meas = cirq.KrausChannel(ops)
@@ -99,7 +99,7 @@ def test_kraus_channel_str():
     )
 
 
-def test_kraus_channel_repr():
+def test_kraus_channel_repr() -> None:
     # This is equivalent to an X-basis measurement.
     ops = [
         np.array([[1, 1], [1, 1]], dtype=np.complex64) * 0.5,
@@ -116,14 +116,14 @@ key='x_meas')"""
     )
 
 
-def test_empty_ops_fails():
-    ops = []
+def test_empty_ops_fails() -> None:
+    ops: list[np.ndarray] = []
 
     with pytest.raises(ValueError, match='must have at least one operation'):
         _ = cirq.KrausChannel(kraus_ops=ops, key='m')
 
 
-def test_ops_mismatch_fails():
+def test_ops_mismatch_fails() -> None:
     op2 = np.zeros((4, 4))
     op2[1][1] = 1
     ops = [np.array([[1, 0], [0, 0]]), op2]
@@ -132,14 +132,14 @@ def test_ops_mismatch_fails():
         _ = cirq.KrausChannel(kraus_ops=ops, key='m')
 
 
-def test_nonqubit_kraus_ops_fails():
+def test_nonqubit_kraus_ops_fails() -> None:
     ops = [np.array([[1, 0, 0], [0, 0, 0]]), np.array([[0, 0, 0], [0, 1, 0]])]
 
     with pytest.raises(ValueError, match='Input Kraus ops'):
         _ = cirq.KrausChannel(kraus_ops=ops, key='m')
 
 
-def test_validate():
+def test_validate() -> None:
     # Not quite CPTP.
     ops = [np.array([[1, 0], [0, 0]]), np.array([[0, 0], [0, 0.9]])]
     with pytest.raises(ValueError, match='CPTP map'):

cirq/ops/named_qubit_test.py

@@ -19,16 +19,16 @@ from cirq.devices.grid_qubit_test import _test_qid_pickled_hash
 from cirq.ops.named_qubit import _pad_digits
 
 
-def test_init():
+def test_init() -> None:
     q = cirq.NamedQubit('a')
     assert q.name == 'a'
 
-    q = cirq.NamedQid('a', dimension=3)
-    assert q.name == 'a'
-    assert q.dimension == 3
+    qid = cirq.NamedQid('a', dimension=3)
+    assert qid.name == 'a'
+    assert qid.dimension == 3
 
 
-def test_named_qubit_str():
+def test_named_qubit_str() -> None:
     q = cirq.NamedQubit('a')
     assert q.name == 'a'
     assert str(q) == 'a'
@@ -37,14 +37,14 @@ def test_named_qubit_str():
     assert str(qid) == 'a (d=3)'
 
 
-def test_named_qubit_repr():
+def test_named_qubit_repr() -> None:
     q = cirq.NamedQubit('a')
     assert repr(q) == "cirq.NamedQubit('a')"
     qid = cirq.NamedQid('a', dimension=3)
     assert repr(qid) == "cirq.NamedQid('a', dimension=3)"
 
 
-def test_named_qubit_pickled_hash():
+def test_named_qubit_pickled_hash() -> None:
     # Use a name that is unlikely to be used by any other tests.
     x = "test_named_qubit_pickled_hash"
     q_bad = cirq.NamedQubit(x)
@@ -53,7 +53,7 @@ def test_named_qubit_pickled_hash():
     _test_qid_pickled_hash(q, q_bad)
 
 
-def test_named_qid_pickled_hash():
+def test_named_qid_pickled_hash() -> None:
     # Use a name that is unlikely to be used by any other tests.
     x = "test_named_qid_pickled_hash"
     q_bad = cirq.NamedQid(x, dimension=3)
@@ -62,7 +62,7 @@ def test_named_qid_pickled_hash():
     _test_qid_pickled_hash(q, q_bad)
 
 
-def test_named_qubit_order():
+def test_named_qubit_order() -> None:
     order = cirq.testing.OrderTester()
     order.add_ascending(
         cirq.NamedQid('', dimension=1),
@@ -110,7 +110,7 @@ def test_named_qubit_order():
     )
 
 
-def test_pad_digits():
+def test_pad_digits() -> None:
     assert _pad_digits('') == ''
     assert _pad_digits('a') == 'a'
     assert _pad_digits('a0') == 'a00000000:1'
@@ -121,7 +121,7 @@ def test_pad_digits():
     assert _pad_digits('a00000000:8') == 'a00000000:8:00000008:1'
 
 
-def test_named_qubit_range():
+def test_named_qubit_range() -> None:
     qubits = cirq.NamedQubit.range(2, prefix='a')
     assert qubits == [cirq.NamedQubit('a0'), cirq.NamedQubit('a1')]
 
@@ -129,7 +129,7 @@ def test_named_qubit_range():
     assert qubits == [cirq.NamedQubit('a-1'), cirq.NamedQubit('a1'), cirq.NamedQubit('a3')]
 
 
-def test_named_qid_range():
+def test_named_qid_range() -> None:
     qids = cirq.NamedQid.range(2, prefix='a', dimension=3)
     assert qids == [cirq.NamedQid('a0', dimension=3), cirq.NamedQid('a1', dimension=3)]
 
@@ -151,7 +151,7 @@ def test_named_qid_range():
     ]
 
 
-def test_to_json():
+def test_to_json() -> None:
     assert cirq.NamedQubit('c')._json_dict_() == {'name': 'c'}
 
     assert cirq.NamedQid('c', dimension=3)._json_dict_() == {'name': 'c', 'dimension': 3}

cirq/ops/op_tree_test.py

@@ -21,7 +21,7 @@ import pytest
 import cirq
 
 
-def test_flatten_op_tree():
+def test_flatten_op_tree() -> None:
     operations = [
         cirq.GateOperation(cirq.testing.SingleQubitGate(), [cirq.NamedQubit(str(i))])
         for i in range(10)
@@ -49,33 +49,33 @@ def test_flatten_op_tree():
 
     # Bad trees.
     with pytest.raises(TypeError):
-        _ = list(cirq.flatten_op_tree(None))
+        _ = list(cirq.flatten_op_tree(None))  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        _ = list(cirq.flatten_op_tree(5))
+        _ = list(cirq.flatten_op_tree(5))  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        _ = list(cirq.flatten_op_tree([operations[0], (4,)]))
+        _ = list(cirq.flatten_op_tree([operations[0], (4,)]))  # type: ignore[list-item]
 
 
-def test_flatten_to_ops_or_moments():
+def test_flatten_to_ops_or_moments() -> None:
     operations = [
         cirq.GateOperation(cirq.testing.SingleQubitGate(), [cirq.NamedQubit(str(i))])
         for i in range(10)
     ]
-    op_tree = [operations[0], cirq.Moment(operations[1:5]), operations[5:]]
+    op_tree: cirq.OP_TREE = [operations[0], cirq.Moment(operations[1:5]), operations[5:]]
     output = [operations[0], cirq.Moment(operations[1:5])] + operations[5:]
     assert list(cirq.flatten_to_ops_or_moments(op_tree)) == output
     assert list(cirq.flatten_op_tree(op_tree, preserve_moments=True)) == output
 
     # Bad trees.
     with pytest.raises(TypeError):
-        _ = list(cirq.flatten_to_ops_or_moments(None))
+        _ = list(cirq.flatten_to_ops_or_moments(None))  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        _ = list(cirq.flatten_to_ops_or_moments(5))
+        _ = list(cirq.flatten_to_ops_or_moments(5))  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        _ = list(cirq.flatten_to_ops_or_moments([operations[0], (4,)]))
+        _ = list(cirq.flatten_to_ops_or_moments([operations[0], (4,)]))  # type: ignore[list-item]
 
 
-def test_freeze_op_tree():
+def test_freeze_op_tree() -> None:
     operations = [
         cirq.GateOperation(cirq.testing.SingleQubitGate(), [cirq.NamedQubit(str(i))])
         for i in range(10)
@@ -97,29 +97,29 @@ def test_freeze_op_tree():
 
     # Bad trees.
     with pytest.raises(TypeError):
-        cirq.freeze_op_tree(None)
+        cirq.freeze_op_tree(None)  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        cirq.freeze_op_tree(5)
+        cirq.freeze_op_tree(5)  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        _ = cirq.freeze_op_tree([operations[0], (4,)])
+        _ = cirq.freeze_op_tree([operations[0], (4,)])  # type: ignore[list-item]
 
 
-def test_transform_bad_tree():
+def test_transform_bad_tree() -> None:
     with pytest.raises(TypeError):
-        _ = list(cirq.transform_op_tree(None))
+        _ = list(cirq.transform_op_tree(None))  # type: ignore[arg-type]
     with pytest.raises(TypeError):
-        _ = list(cirq.transform_op_tree(5))
+        _ = list(cirq.transform_op_tree(5))  # type: ignore[arg-type]
     with pytest.raises(TypeError):
         _ = list(
             cirq.flatten_op_tree(
                 cirq.transform_op_tree(
-                    [cirq.GateOperation(cirq.Gate(), [cirq.NamedQubit('q')]), (4,)]
+                    [cirq.GateOperation(cirq.Gate(), [cirq.NamedQubit('q')]), (4,)]  # type: ignore
                 )
             )
         )
 
 
-def test_transform_leaves():
+def test_transform_leaves() -> None:
     gs = [cirq.testing.SingleQubitGate() for _ in range(10)]
     operations = [cirq.GateOperation(gs[i], [cirq.NamedQubit(str(i))]) for i in range(10)]
     expected = [cirq.GateOperation(gs[i], [cirq.NamedQubit(str(i) + 'a')]) for i in range(10)]
@@ -153,7 +153,7 @@ def test_transform_leaves():
     )
 
 
-def test_transform_internal_nodes():
+def test_transform_internal_nodes() -> None:
     operations = [
         cirq.GateOperation(cirq.testing.SingleQubitGate(), [cirq.LineQubit(2 * i)])
         for i in range(10)

cirq/ops/phased_x_gate_test.py

@@ -26,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)
     )
@@ -35,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
@@ -53,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
 
@@ -73,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),
@@ -124,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),
@@ -142,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(
@@ -158,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
     )
@@ -189,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
     )
@@ -218,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),
@@ -236,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)
@@ -257,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]
@@ -271,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_test.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import random
+from typing import cast
 
 import numpy as np
 import pytest
@@ -11,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)
@@ -61,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)
 
@@ -148,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)),
@@ -220,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
     )
@@ -235,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()
@@ -259,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()
@@ -267,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()
@@ -299,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)"