cirq-core 1.6.0.dev20250508231110__py3-none-any.whl → 1.6.0.dev20250512192405__py3-none-any.whl

cirq/ops/parity_gates_test.py

@@ -22,17 +22,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 +49,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 +82,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 +96,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 +118,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 +133,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 +154,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 +168,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 +190,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 +211,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 +232,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 +246,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 +256,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 +268,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 +278,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 +287,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 +300,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 +309,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 +323,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 +332,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_test.py

@@ -20,14 +20,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 +44,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 +59,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 +78,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 +96,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 +106,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 +125,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 +142,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 +172,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 +181,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 +207,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)

cirq/ops/pauli_interaction_gate_test.py

@@ -32,11 +32,11 @@ def _all_interaction_gates(exponents=(1,)):
 
 
 @pytest.mark.parametrize('gate', _all_interaction_gates())
-def test_pauli_interaction_gates_consistent_protocols(gate):
+def test_pauli_interaction_gates_consistent_protocols(gate) -> None:
     cirq.testing.assert_implements_consistent_protocols(gate)
 
 
-def test_eq_ne_and_hash():
+def test_eq_ne_and_hash() -> None:
     eq = cirq.testing.EqualsTester()
     for pauli0, invert0, pauli1, invert1, e in itertools.product(
         _paulis, _bools, _paulis, _bools, (0.125, -0.25, 1)
@@ -46,7 +46,7 @@ def test_eq_ne_and_hash():
         )
 
 
-def test_exponent_shifts_are_equal():
+def test_exponent_shifts_are_equal() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(
         cirq.PauliInteractionGate(cirq.X, False, cirq.X, False, exponent=e)
@@ -67,7 +67,7 @@ def test_exponent_shifts_are_equal():
 
 
 @pytest.mark.parametrize('gate', _all_interaction_gates(exponents=(0.1, -0.25, 0.5, 1)))
-def test_interchangeable_qubits(gate):
+def test_interchangeable_qubits(gate) -> None:
     q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1')
     op0 = gate(q0, q1)
     op1 = gate(q1, q0)
@@ -78,7 +78,7 @@ def test_interchangeable_qubits(gate):
     assert same == same_check
 
 
-def test_exponent():
+def test_exponent() -> None:
     cnot = cirq.PauliInteractionGate(cirq.Z, False, cirq.X, False)
     np.testing.assert_almost_equal(
         cirq.unitary(cnot**0.5),
@@ -93,18 +93,18 @@ def test_exponent():
     )
 
 
-def test_repr():
+def test_repr() -> None:
     cnot = cirq.PauliInteractionGate(cirq.Z, False, cirq.X, False)
     cirq.testing.assert_equivalent_repr(cnot)
 
 
-def test_decomposes_despite_symbol():
+def test_decomposes_despite_symbol() -> None:
     q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1')
     gate = cirq.PauliInteractionGate(cirq.Z, False, cirq.X, False, exponent=sympy.Symbol('x'))
     assert cirq.decompose_once_with_qubits(gate, [q0, q1])
 
 
-def test_text_diagrams():
+def test_text_diagrams() -> None:
     q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1')
     circuit = cirq.Circuit(
         cirq.PauliInteractionGate(cirq.X, False, cirq.X, False)(q0, q1),

cirq/ops/pauli_sum_exponential_test.py

@@ -22,12 +22,12 @@ import cirq.testing
 q0, q1, q2, q3 = cirq.LineQubit.range(4)
 
 
-def test_raises_for_non_commuting_paulis():
+def test_raises_for_non_commuting_paulis() -> None:
     with pytest.raises(ValueError, match='commuting'):
         cirq.PauliSumExponential(cirq.X(q0) + cirq.Z(q0), np.pi / 2)
 
 
-def test_raises_for_non_hermitian_pauli():
+def test_raises_for_non_hermitian_pauli() -> None:
     with pytest.raises(ValueError, match='hermitian'):
         cirq.PauliSumExponential(cirq.X(q0) + 1j * cirq.Z(q1), np.pi / 2)
 
@@ -46,7 +46,7 @@ def test_raises_for_non_hermitian_pauli():
         ),
     ),
 )
-def test_pauli_sum_exponential_qubits(psum_exp, expected_qubits):
+def test_pauli_sum_exponential_qubits(psum_exp, expected_qubits) -> None:
     assert psum_exp.qubits == expected_qubits
 
 
@@ -67,7 +67,7 @@ def test_pauli_sum_exponential_qubits(psum_exp, expected_qubits):
         ),
     ),
 )
-def test_pauli_sum_exponential_with_qubits(psum_exp, expected_psum_exp):
+def test_pauli_sum_exponential_with_qubits(psum_exp, expected_psum_exp) -> None:
     assert psum_exp.with_qubits(*expected_psum_exp.qubits) == expected_psum_exp
 
 
@@ -79,7 +79,7 @@ def test_pauli_sum_exponential_with_qubits(psum_exp, expected_psum_exp):
         (cirq.X(q0) * cirq.Y(q1) + cirq.Y(q1) * cirq.Z(q3), np.pi),
     ),
 )
-def test_with_parameters_resolved_by(psum, exp):
+def test_with_parameters_resolved_by(psum, exp) -> None:
     psum_exp = cirq.PauliSumExponential(psum, sympy.Symbol("theta"))
     resolver = cirq.ParamResolver({"theta": exp})
     actual = cirq.resolve_parameters(psum_exp, resolver)
@@ -87,7 +87,7 @@ def test_with_parameters_resolved_by(psum, exp):
     assert actual == expected
 
 
-def test_pauli_sum_exponential_parameterized_matrix_raises():
+def test_pauli_sum_exponential_parameterized_matrix_raises() -> None:
     with pytest.raises(ValueError, match='parameterized'):
         cirq.PauliSumExponential(cirq.X(q0) + cirq.Z(q1), sympy.Symbol("theta")).matrix()
 
@@ -102,7 +102,7 @@ def test_pauli_sum_exponential_parameterized_matrix_raises():
         ),
     ),
 )
-def test_pauli_sum_exponential_has_correct_unitary(psum_exp, expected_unitary):
+def test_pauli_sum_exponential_has_correct_unitary(psum_exp, expected_unitary) -> None:
     assert cirq.has_unitary(psum_exp)
     assert np.allclose(cirq.unitary(psum_exp), expected_unitary)
 
@@ -127,7 +127,7 @@ def test_pauli_sum_exponential_has_correct_unitary(psum_exp, expected_unitary):
         ),
     ),
 )
-def test_pauli_sum_exponential_pow(psum_exp, power, expected_psum):
+def test_pauli_sum_exponential_pow(psum_exp, power, expected_psum) -> None:
     assert psum_exp**power == expected_psum
 
 
@@ -138,7 +138,7 @@ def test_pauli_sum_exponential_pow(psum_exp, power, expected_psum):
         (cirq.PauliSumExponential(2j * cirq.X(q0) + 3j * cirq.Z(q1), np.pi / 2)),
     ),
 )
-def test_pauli_sum_exponential_repr(psum_exp):
+def test_pauli_sum_exponential_repr(psum_exp) -> None:
     cirq.testing.assert_equivalent_repr(psum_exp)
 
 
@@ -156,5 +156,5 @@ def test_pauli_sum_exponential_repr(psum_exp):
         ),
     ),
 )
-def test_pauli_sum_exponential_formatting(psum_exp, expected_str):
+def test_pauli_sum_exponential_formatting(psum_exp, expected_str) -> None:
     assert str(psum_exp) == expected_str

cirq/ops/permutation_gate_test.py

@@ -19,7 +19,7 @@ import cirq
 from cirq.ops import QubitPermutationGate
 
 
-def test_permutation_gate_equality():
+def test_permutation_gate_equality() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(
         lambda: QubitPermutationGate([0, 1]), lambda: QubitPermutationGate((0, 1))
@@ -27,7 +27,7 @@ def test_permutation_gate_equality():
     eq.add_equality_group(QubitPermutationGate([1, 0]), QubitPermutationGate((1, 0)))
 
 
-def test_permutation_gate_repr():
+def test_permutation_gate_repr() -> None:
     cirq.testing.assert_equivalent_repr(QubitPermutationGate([0, 1]))
 
 
@@ -35,26 +35,26 @@ rs = np.random.RandomState(seed=1234)
 
 
 @pytest.mark.parametrize('permutation', [rs.permutation(i) for i in range(3, 7)])
-def test_permutation_gate_consistent_protocols(permutation):
+def test_permutation_gate_consistent_protocols(permutation) -> None:
     gate = QubitPermutationGate(list(permutation))
     cirq.testing.assert_implements_consistent_protocols(gate)
 
 
-def test_permutation_gate_invalid_indices():
+def test_permutation_gate_invalid_indices() -> None:
     with pytest.raises(ValueError, match="Invalid indices"):
         QubitPermutationGate([1, 0, 2, 4])
     with pytest.raises(ValueError, match="Invalid indices"):
         QubitPermutationGate([-1])
 
 
-def test_permutation_gate_invalid_permutation():
+def test_permutation_gate_invalid_permutation() -> None:
     with pytest.raises(ValueError, match="Invalid permutation"):
         QubitPermutationGate([1, 1])
     with pytest.raises(ValueError, match="Invalid permutation"):
         QubitPermutationGate([])
 
 
-def test_permutation_gate_diagram():
+def test_permutation_gate_diagram() -> None:
     q = cirq.LineQubit.range(6)
     cirq.testing.assert_has_diagram(
         cirq.Circuit(cirq.X(q[0]), cirq.X(q[5]), QubitPermutationGate([3, 2, 1, 0]).on(*q[1:5])),
@@ -74,7 +74,7 @@ def test_permutation_gate_diagram():
     )
 
 
-def test_permutation_gate_json_dict():
+def test_permutation_gate_json_dict() -> None:
     assert cirq.QubitPermutationGate([0, 1, 2])._json_dict_() == {'permutation': (0, 1, 2)}
 
 
@@ -96,7 +96,7 @@ def test_permutation_gate_json_dict():
         ],
     ],
 )
-def test_permutation_gate_maps(maps, permutation):
+def test_permutation_gate_maps(maps, permutation) -> None:
     qs = cirq.LineQubit.range(len(permutation))
     permutationOp = cirq.QubitPermutationGate(permutation).on(*qs)
     circuit = cirq.Circuit(permutationOp)