cirq-core 1.6.0.dev20250509215532__py3-none-any.whl → 1.6.0.dev20250514001158__py3-none-any.whl

cirq/ops/common_channels_test.py

@@ -56,7 +56,7 @@ def assert_mixtures_equal(actual, expected):
         np.testing.assert_almost_equal(a[1], e[1])
 
 
-def test_asymmetric_depolarizing_channel():
+def test_asymmetric_depolarizing_channel() -> None:
     d = cirq.asymmetric_depolarize(0.1, 0.2, 0.3)
     np.testing.assert_almost_equal(
         cirq.kraus(d),
@@ -68,17 +68,17 @@ def test_asymmetric_depolarizing_channel():
     assert cirq.AsymmetricDepolarizingChannel(p_x=0, p_y=0.1, p_z=0).num_qubits() == 1
 
 
-def test_asymmetric_depolarizing_mixture():
+def test_asymmetric_depolarizing_mixture() -> None:
     d = cirq.asymmetric_depolarize(0.1, 0.2, 0.3)
     assert_mixtures_equal(cirq.mixture(d), ((0.4, np.eye(2)), (0.1, X), (0.2, Y), (0.3, Z)))
     assert cirq.has_mixture(d)
 
 
-def test_asymmetric_depolarizing_channel_repr():
+def test_asymmetric_depolarizing_channel_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.AsymmetricDepolarizingChannel(0.1, 0.2, 0.3))
 
 
-def test_asymmetric_depolarizing_channel_str():
+def test_asymmetric_depolarizing_channel_str() -> None:
     assert (
         str(cirq.asymmetric_depolarize(0.1, 0.2, 0.3))
         == "asymmetric_depolarize(error_probabilities={'I': 0.3999999999999999, "
@@ -86,7 +86,7 @@ def test_asymmetric_depolarizing_channel_str():
     )
 
 
-def test_asymmetric_depolarizing_channel_eq():
+def test_asymmetric_depolarizing_channel_eq() -> None:
     a = cirq.asymmetric_depolarize(0.0099999, 0.01)
     b = cirq.asymmetric_depolarize(0.01, 0.0099999)
     c = cirq.asymmetric_depolarize(0.0, 0.0, 0.0)
@@ -109,7 +109,7 @@ def test_asymmetric_depolarizing_channel_eq():
 @pytest.mark.parametrize(
     'p_x,p_y,p_z', ((-0.1, 0.0, 0.0), (0.0, -0.1, 0.0), (0.0, 0.0, -0.1), (0.1, -0.1, 0.1))
 )
-def test_asymmetric_depolarizing_channel_negative_probability(p_x, p_y, p_z):
+def test_asymmetric_depolarizing_channel_negative_probability(p_x, p_y, p_z) -> None:
     with pytest.raises(ValueError, match='was less than 0'):
         cirq.asymmetric_depolarize(p_x, p_y, p_z)
 
@@ -117,12 +117,12 @@ def test_asymmetric_depolarizing_channel_negative_probability(p_x, p_y, p_z):
 @pytest.mark.parametrize(
     'p_x,p_y,p_z', ((1.1, 0.0, 0.0), (0.0, 1.1, 0.0), (0.0, 0.0, 1.1), (0.1, 0.9, 0.1))
 )
-def test_asymmetric_depolarizing_channel_bigly_probability(p_x, p_y, p_z):
+def test_asymmetric_depolarizing_channel_bigly_probability(p_x, p_y, p_z) -> None:
     with pytest.raises(ValueError, match='was greater than 1'):
         cirq.asymmetric_depolarize(p_x, p_y, p_z)
 
 
-def test_asymmetric_depolarizing_channel_text_diagram():
+def test_asymmetric_depolarizing_channel_text_diagram() -> None:
     a = cirq.asymmetric_depolarize(1 / 9, 2 / 9, 3 / 9)
     assert cirq.circuit_diagram_info(a, args=no_precision) == cirq.CircuitDiagramInfo(
         wire_symbols=('A(0.1111111111111111,0.2222222222222222,' + '0.3333333333333333)',)
@@ -135,7 +135,7 @@ def test_asymmetric_depolarizing_channel_text_diagram():
     )
 
 
-def test_depolarizing_channel():
+def test_depolarizing_channel() -> None:
     d = cirq.depolarize(0.3)
     np.testing.assert_almost_equal(
         cirq.kraus(d),
@@ -145,7 +145,7 @@ def test_depolarizing_channel():
     cirq.testing.assert_consistent_mixture(d)
 
 
-def test_depolarizing_channel_two_qubits():
+def test_depolarizing_channel_two_qubits() -> None:
     d = cirq.depolarize(0.15, n_qubits=2)
     np.testing.assert_almost_equal(
         cirq.kraus(d),
@@ -182,13 +182,13 @@ def test_depolarizing_channel_two_qubits():
     )
 
 
-def test_depolarizing_mixture():
+def test_depolarizing_mixture() -> None:
     d = cirq.depolarize(0.3)
     assert_mixtures_equal(cirq.mixture(d), ((0.7, np.eye(2)), (0.1, X), (0.1, Y), (0.1, Z)))
     assert cirq.has_mixture(d)
 
 
-def test_depolarizing_mixture_two_qubits():
+def test_depolarizing_mixture_two_qubits() -> None:
     d = cirq.depolarize(0.15, n_qubits=2)
     assert_mixtures_equal(
         cirq.mixture(d),
@@ -214,23 +214,23 @@ def test_depolarizing_mixture_two_qubits():
     assert cirq.has_mixture(d)
 
 
-def test_depolarizing_channel_repr():
+def test_depolarizing_channel_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.DepolarizingChannel(0.3))
 
 
-def test_depolarizing_channel_repr_two_qubits():
+def test_depolarizing_channel_repr_two_qubits() -> None:
     cirq.testing.assert_equivalent_repr(cirq.DepolarizingChannel(0.3, n_qubits=2))
 
 
-def test_depolarizing_channel_str():
+def test_depolarizing_channel_str() -> None:
     assert str(cirq.depolarize(0.3)) == 'depolarize(p=0.3)'
 
 
-def test_depolarizing_channel_str_two_qubits():
+def test_depolarizing_channel_str_two_qubits() -> None:
     assert str(cirq.depolarize(0.3, n_qubits=2)) == 'depolarize(p=0.3,n_qubits=2)'
 
 
-def test_deprecated_on_each_for_depolarizing_channel_one_qubit():
+def test_deprecated_on_each_for_depolarizing_channel_one_qubit() -> None:
     q0 = cirq.LineQubit.range(1)
     op = cirq.DepolarizingChannel(p=0.1, n_qubits=1)
 
@@ -240,7 +240,7 @@ def test_deprecated_on_each_for_depolarizing_channel_one_qubit():
         op.on_each('bogus object')
 
 
-def test_deprecated_on_each_for_depolarizing_channel_two_qubits():
+def test_deprecated_on_each_for_depolarizing_channel_two_qubits() -> None:
     q0, q1, q2, q3, q4, q5 = cirq.LineQubit.range(6)
     op = cirq.DepolarizingChannel(p=0.1, n_qubits=2)
 
@@ -259,19 +259,19 @@ def test_deprecated_on_each_for_depolarizing_channel_two_qubits():
         op.on_each([(False, None)])
 
 
-def test_depolarizing_channel_apply_two_qubits():
+def test_depolarizing_channel_apply_two_qubits() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     op = cirq.DepolarizingChannel(p=0.1, n_qubits=2)
     op(q0, q1)
 
 
-def test_asymmetric_depolarizing_channel_apply_two_qubits():
+def test_asymmetric_depolarizing_channel_apply_two_qubits() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     op = cirq.AsymmetricDepolarizingChannel(error_probabilities={'XX': 0.1})
     op(q0, q1)
 
 
-def test_depolarizing_channel_eq():
+def test_depolarizing_channel_eq() -> None:
     a = cirq.depolarize(p=0.0099999)
     b = cirq.depolarize(p=0.01)
     c = cirq.depolarize(0.0)
@@ -288,14 +288,14 @@ def test_depolarizing_channel_eq():
     et.add_equality_group(cirq.depolarize(1.0, n_qubits=2))
 
 
-def test_depolarizing_channel_invalid_probability():
+def test_depolarizing_channel_invalid_probability() -> None:
     with pytest.raises(ValueError, match=re.escape('p(I) was greater than 1.')):
         cirq.depolarize(-0.1)
     with pytest.raises(ValueError, match=re.escape('p(I) was less than 0.')):
         cirq.depolarize(1.1)
 
 
-def test_depolarizing_channel_text_diagram():
+def test_depolarizing_channel_text_diagram() -> None:
     d = cirq.depolarize(0.1234567)
     assert cirq.circuit_diagram_info(d, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
         wire_symbols=('D(0.123457)',)
@@ -308,7 +308,7 @@ def test_depolarizing_channel_text_diagram():
     )
 
 
-def test_depolarizing_channel_text_diagram_two_qubits():
+def test_depolarizing_channel_text_diagram_two_qubits() -> None:
     d = cirq.depolarize(0.1234567, n_qubits=2)
     assert cirq.circuit_diagram_info(d, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
         wire_symbols=('D(0.123457)', '#2')
@@ -321,7 +321,7 @@ def test_depolarizing_channel_text_diagram_two_qubits():
     )
 
 
-def test_generalized_amplitude_damping_channel():
+def test_generalized_amplitude_damping_channel() -> None:
     d = cirq.generalized_amplitude_damp(0.1, 0.3)
     np.testing.assert_almost_equal(
         cirq.kraus(d),
@@ -336,18 +336,18 @@ def test_generalized_amplitude_damping_channel():
     assert not cirq.has_mixture(d)
 
 
-def test_generalized_amplitude_damping_repr():
+def test_generalized_amplitude_damping_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.GeneralizedAmplitudeDampingChannel(0.1, 0.3))
 
 
-def test_generalized_amplitude_damping_str():
+def test_generalized_amplitude_damping_str() -> None:
     assert (
         str(cirq.generalized_amplitude_damp(0.1, 0.3))
         == 'generalized_amplitude_damp(p=0.1,gamma=0.3)'
     )
 
 
-def test_generalized_amplitude_damping_channel_eq():
+def test_generalized_amplitude_damping_channel_eq() -> None:
     a = cirq.generalized_amplitude_damp(0.0099999, 0.01)
     b = cirq.generalized_amplitude_damp(0.01, 0.0099999)
 
@@ -364,18 +364,18 @@ def test_generalized_amplitude_damping_channel_eq():
 
 
 @pytest.mark.parametrize('p, gamma', ((-0.1, 0.0), (0.0, -0.1), (0.1, -0.1), (-0.1, 0.1)))
-def test_generalized_amplitude_damping_channel_negative_probability(p, gamma):
+def test_generalized_amplitude_damping_channel_negative_probability(p, gamma) -> None:
     with pytest.raises(ValueError, match='was less than 0'):
         cirq.generalized_amplitude_damp(p, gamma)
 
 
 @pytest.mark.parametrize('p,gamma', ((1.1, 0.0), (0.0, 1.1), (1.1, 1.1)))
-def test_generalized_amplitude_damping_channel_bigly_probability(p, gamma):
+def test_generalized_amplitude_damping_channel_bigly_probability(p, gamma) -> None:
     with pytest.raises(ValueError, match='was greater than 1'):
         cirq.generalized_amplitude_damp(p, gamma)
 
 
-def test_generalized_amplitude_damping_channel_text_diagram():
+def test_generalized_amplitude_damping_channel_text_diagram() -> None:
     a = cirq.generalized_amplitude_damp(0.1, 0.39558391)
     assert cirq.circuit_diagram_info(a, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
         wire_symbols=('GAD(0.1,0.395584)',)
@@ -388,7 +388,7 @@ def test_generalized_amplitude_damping_channel_text_diagram():
     )
 
 
-def test_amplitude_damping_channel():
+def test_amplitude_damping_channel() -> None:
     d = cirq.amplitude_damp(0.3)
     np.testing.assert_almost_equal(
         cirq.kraus(d),
@@ -401,15 +401,15 @@ def test_amplitude_damping_channel():
     assert not cirq.has_mixture(d)
 
 
-def test_amplitude_damping_channel_repr():
+def test_amplitude_damping_channel_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.AmplitudeDampingChannel(0.3))
 
 
-def test_amplitude_damping_channel_str():
+def test_amplitude_damping_channel_str() -> None:
     assert str(cirq.amplitude_damp(0.3)) == 'amplitude_damp(gamma=0.3)'
 
 
-def test_amplitude_damping_channel_eq():
+def test_amplitude_damping_channel_eq() -> None:
     a = cirq.amplitude_damp(0.0099999)
     b = cirq.amplitude_damp(0.01)
     c = cirq.amplitude_damp(0.0)
@@ -425,14 +425,14 @@ def test_amplitude_damping_channel_eq():
     et.add_equality_group(cirq.amplitude_damp(0.8))
 
 
-def test_amplitude_damping_channel_invalid_probability():
+def test_amplitude_damping_channel_invalid_probability() -> None:
     with pytest.raises(ValueError, match='was less than 0'):
         cirq.amplitude_damp(-0.1)
     with pytest.raises(ValueError, match='was greater than 1'):
         cirq.amplitude_damp(1.1)
 
 
-def test_amplitude_damping_channel_text_diagram():
+def test_amplitude_damping_channel_text_diagram() -> None:
     ad = cirq.amplitude_damp(0.38059322)
     assert cirq.circuit_diagram_info(ad, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
         wire_symbols=('AD(0.380593)',)
@@ -445,7 +445,7 @@ def test_amplitude_damping_channel_text_diagram():
     )
 
 
-def test_reset_channel():
+def test_reset_channel() -> None:
     r = cirq.reset(cirq.LineQubit(0))
     np.testing.assert_almost_equal(
         cirq.kraus(r), (np.array([[1.0, 0.0], [0.0, 0]]), np.array([[0.0, 1.0], [0.0, 0.0]]))
@@ -470,22 +470,22 @@ def test_reset_channel():
     assert cirq.qid_shape(r) == (3,)
 
 
-def test_reset_channel_equality():
+def test_reset_channel_equality() -> None:
     assert cirq.reset(cirq.LineQubit(0)).gate == cirq.ResetChannel()
     assert cirq.reset(cirq.LineQid(0, 3)).gate == cirq.ResetChannel(3)
 
 
-def test_reset_channel_repr():
+def test_reset_channel_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.ResetChannel())
     cirq.testing.assert_equivalent_repr(cirq.ResetChannel(3))
 
 
-def test_reset_channel_str():
+def test_reset_channel_str() -> None:
     assert str(cirq.ResetChannel()) == 'reset'
     assert str(cirq.ResetChannel(3)) == 'reset'
 
 
-def test_reset_channel_text_diagram():
+def test_reset_channel_text_diagram() -> None:
     assert cirq.circuit_diagram_info(cirq.ResetChannel()) == cirq.CircuitDiagramInfo(
         wire_symbols=('R',)
     )
@@ -494,7 +494,7 @@ def test_reset_channel_text_diagram():
     )
 
 
-def test_reset_act_on():
+def test_reset_act_on() -> None:
     with pytest.raises(TypeError, match="Failed to act"):
         cirq.act_on(cirq.ResetChannel(), ExampleSimulationState(), qubits=())
 
@@ -523,7 +523,7 @@ def test_reset_act_on():
     )
 
 
-def test_reset_each():
+def test_reset_each() -> None:
     qubits = cirq.LineQubit.range(8)
     for n in range(len(qubits) + 1):
         ops = cirq.reset_each(*qubits[:n])
@@ -533,14 +533,14 @@ def test_reset_each():
             assert op.qubits == (qubits[i],)
 
 
-def test_reset_consistency():
+def test_reset_consistency() -> None:
     two_d_chan = cirq.ResetChannel()
     cirq.testing.assert_has_consistent_apply_channel(two_d_chan)
     three_d_chan = cirq.ResetChannel(dimension=3)
     cirq.testing.assert_has_consistent_apply_channel(three_d_chan)
 
 
-def test_phase_damping_channel():
+def test_phase_damping_channel() -> None:
     d = cirq.phase_damp(0.3)
     np.testing.assert_almost_equal(
         cirq.kraus(d),
@@ -553,15 +553,15 @@ def test_phase_damping_channel():
     assert not cirq.has_mixture(d)
 
 
-def test_phase_damping_channel_repr():
+def test_phase_damping_channel_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.PhaseDampingChannel(0.3))
 
 
-def test_phase_damping_channel_str():
+def test_phase_damping_channel_str() -> None:
     assert str(cirq.phase_damp(0.3)) == 'phase_damp(gamma=0.3)'
 
 
-def test_phase_damping_channel_eq():
+def test_phase_damping_channel_eq() -> None:
     a = cirq.phase_damp(0.0099999)
     b = cirq.phase_damp(0.01)
     c = cirq.phase_damp(0.0)
@@ -577,14 +577,14 @@ def test_phase_damping_channel_eq():
     et.add_equality_group(cirq.phase_damp(0.8))
 
 
-def test_phase_damping_channel_invalid_probability():
+def test_phase_damping_channel_invalid_probability() -> None:
     with pytest.raises(ValueError, match='was less than 0'):
         cirq.phase_damp(-0.1)
     with pytest.raises(ValueError, match='was greater than 1'):
         cirq.phase_damp(1.1)
 
 
-def test_phase_damping_channel_text_diagram():
+def test_phase_damping_channel_text_diagram() -> None:
     pd = cirq.phase_damp(0.1000009)
     assert cirq.circuit_diagram_info(pd, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
         wire_symbols=('PD(0.100001)',)
@@ -597,7 +597,7 @@ def test_phase_damping_channel_text_diagram():
     )
 
 
-def test_phase_damp_consistency():
+def test_phase_damp_consistency() -> None:
     full_damp = cirq.PhaseDampingChannel(gamma=1)
     cirq.testing.assert_has_consistent_apply_channel(full_damp)
     partial_damp = cirq.PhaseDampingChannel(gamma=0.5)
@@ -606,7 +606,7 @@ def test_phase_damp_consistency():
     cirq.testing.assert_has_consistent_apply_channel(no_damp)
 
 
-def test_phase_flip_channel():
+def test_phase_flip_channel() -> None:
     d = cirq.phase_flip(0.3)
     np.testing.assert_almost_equal(
         cirq.kraus(d), (np.sqrt(1.0 - 0.3) * np.eye(2), np.sqrt(0.3) * Z)
@@ -615,28 +615,28 @@ def test_phase_flip_channel():
     cirq.testing.assert_consistent_mixture(d)
 
 
-def test_phase_flip_mixture():
+def test_phase_flip_mixture() -> None:
     d = cirq.phase_flip(0.3)
     assert_mixtures_equal(cirq.mixture(d), ((0.7, np.eye(2)), (0.3, Z)))
     assert cirq.has_mixture(d)
 
 
-def test_phase_flip_overload():
+def test_phase_flip_overload() -> None:
     d = cirq.phase_flip()
     d2 = cirq.phase_flip(0.3)
     assert str(d) == 'Z'
     assert str(d2) == 'phase_flip(p=0.3)'
 
 
-def test_phase_flip_channel_repr():
+def test_phase_flip_channel_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.PhaseFlipChannel(0.3))
 
 
-def test_phase_flip_channel_str():
+def test_phase_flip_channel_str() -> None:
     assert str(cirq.phase_flip(0.3)) == 'phase_flip(p=0.3)'
 
 
-def test_phase_flip_channel_eq():
+def test_phase_flip_channel_eq() -> None:
     a = cirq.phase_flip(0.0099999)
     b = cirq.phase_flip(0.01)
     c = cirq.phase_flip(0.0)
@@ -652,14 +652,14 @@ def test_phase_flip_channel_eq():
     et.add_equality_group(cirq.phase_flip(0.8))
 
 
-def test_phase_flip_channel_invalid_probability():
+def test_phase_flip_channel_invalid_probability() -> None:
     with pytest.raises(ValueError, match='was less than 0'):
         cirq.phase_flip(-0.1)
     with pytest.raises(ValueError, match='was greater than 1'):
         cirq.phase_flip(1.1)
 
 
-def test_phase_flip_channel_text_diagram():
+def test_phase_flip_channel_text_diagram() -> None:
     pf = cirq.phase_flip(0.987654)
     assert cirq.circuit_diagram_info(pf, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
         wire_symbols=('PF(0.987654)',)
@@ -672,7 +672,7 @@ def test_phase_flip_channel_text_diagram():
     )
 
 
-def test_bit_flip_channel():
+def test_bit_flip_channel() -> None:
     d = cirq.bit_flip(0.3)
     np.testing.assert_almost_equal(
         cirq.kraus(d), (np.sqrt(1.0 - 0.3) * np.eye(2), np.sqrt(0.3) * X)
@@ -681,28 +681,28 @@ def test_bit_flip_channel():
     cirq.testing.assert_consistent_mixture(d)
 
 
-def test_bit_flip_mixture():
+def test_bit_flip_mixture() -> None:
     d = cirq.bit_flip(0.3)
     assert_mixtures_equal(cirq.mixture(d), ((0.7, np.eye(2)), (0.3, X)))
     assert cirq.has_mixture(d)
 
 
-def test_bit_flip_overload():
+def test_bit_flip_overload() -> None:
     d = cirq.bit_flip()
     d2 = cirq.bit_flip(0.3)
     assert str(d) == 'X'
     assert str(d2) == 'bit_flip(p=0.3)'
 
 
-def test_bit_flip_channel_repr():
+def test_bit_flip_channel_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.BitFlipChannel(0.3))
 
 
-def test_bit_flip_channel_str():
+def test_bit_flip_channel_str() -> None:
     assert str(cirq.bit_flip(0.3)) == 'bit_flip(p=0.3)'
 
 
-def test_bit_flip_channel_eq():
+def test_bit_flip_channel_eq() -> None:
     a = cirq.bit_flip(0.0099999)
     b = cirq.bit_flip(0.01)
     c = cirq.bit_flip(0.0)
@@ -718,14 +718,14 @@ def test_bit_flip_channel_eq():
     et.add_equality_group(cirq.bit_flip(0.8))
 
 
-def test_bit_flip_channel_invalid_probability():
+def test_bit_flip_channel_invalid_probability() -> None:
     with pytest.raises(ValueError, match='was less than 0'):
         cirq.bit_flip(-0.1)
     with pytest.raises(ValueError, match='was greater than 1'):
         cirq.bit_flip(1.1)
 
 
-def test_bit_flip_channel_text_diagram():
+def test_bit_flip_channel_text_diagram() -> None:
     bf = cirq.bit_flip(0.1234567)
     assert cirq.circuit_diagram_info(bf, args=round_to_6_prec) == cirq.CircuitDiagramInfo(
         wire_symbols=('BF(0.123457)',)
@@ -738,7 +738,7 @@ def test_bit_flip_channel_text_diagram():
     )
 
 
-def test_stabilizer_supports_depolarize():
+def test_stabilizer_supports_depolarize() -> None:
     with pytest.raises(TypeError, match="act_on"):
         for _ in range(100):
             cirq.act_on(cirq.depolarize(3 / 4), ExampleSimulationState(), qubits=())
@@ -749,7 +749,7 @@ def test_stabilizer_supports_depolarize():
     assert 5 < m < 95
 
 
-def test_default_asymmetric_depolarizing_channel():
+def test_default_asymmetric_depolarizing_channel() -> None:
     d = cirq.asymmetric_depolarize()
     assert d.p_i == 1.0
     assert d.p_x == 0.0
@@ -758,28 +758,28 @@ def test_default_asymmetric_depolarizing_channel():
     assert d.num_qubits() == 1
 
 
-def test_bad_error_probabilities_gate():
+def test_bad_error_probabilities_gate() -> None:
     with pytest.raises(ValueError, match='AB is not made solely of I, X, Y, Z.'):
         cirq.asymmetric_depolarize(error_probabilities={'AB': 1.0})
     with pytest.raises(ValueError, match='Y must have 2 Pauli gates.'):
         cirq.asymmetric_depolarize(error_probabilities={'IX': 0.8, 'Y': 0.2})
 
 
-def test_bad_probs():
+def test_bad_probs() -> None:
     with pytest.raises(ValueError, match=re.escape('p(X) was greater than 1.')):
         cirq.asymmetric_depolarize(error_probabilities={'X': 1.1, 'Y': -0.1})
     with pytest.raises(ValueError, match=re.escape('Probabilities do not add up to 1')):
         cirq.asymmetric_depolarize(error_probabilities={'X': 0.7, 'Y': 0.6})
 
 
-def test_missing_prob_mass():
+def test_missing_prob_mass() -> None:
     with pytest.raises(ValueError, match='Probabilities do not add up to 1'):
         cirq.asymmetric_depolarize(error_probabilities={'X': 0.1, 'I': 0.2})
     d = cirq.asymmetric_depolarize(error_probabilities={'X': 0.1})
     np.testing.assert_almost_equal(d.error_probabilities['I'], 0.9)
 
 
-def test_multi_asymmetric_depolarizing_channel():
+def test_multi_asymmetric_depolarizing_channel() -> None:
     d = cirq.asymmetric_depolarize(error_probabilities={'II': 0.8, 'XX': 0.2})
     np.testing.assert_almost_equal(
         cirq.kraus(d), (np.sqrt(0.8) * np.eye(4), np.sqrt(0.2) * np.kron(X, X))
@@ -798,20 +798,20 @@ def test_multi_asymmetric_depolarizing_channel():
         assert d.p_z == 0.0
 
 
-def test_multi_asymmetric_depolarizing_mixture():
+def test_multi_asymmetric_depolarizing_mixture() -> None:
     d = cirq.asymmetric_depolarize(error_probabilities={'II': 0.8, 'XX': 0.2})
     assert_mixtures_equal(cirq.mixture(d), ((0.8, np.eye(4)), (0.2, np.kron(X, X))))
     assert cirq.has_mixture(d)
     np.testing.assert_equal(d._num_qubits_(), 2)
 
 
-def test_multi_asymmetric_depolarizing_channel_repr():
+def test_multi_asymmetric_depolarizing_channel_repr() -> None:
     cirq.testing.assert_equivalent_repr(
         cirq.AsymmetricDepolarizingChannel(error_probabilities={'II': 0.8, 'XX': 0.2})
     )
 
 
-def test_multi_asymmetric_depolarizing_eq():
+def test_multi_asymmetric_depolarizing_eq() -> None:
     a = cirq.asymmetric_depolarize(error_probabilities={'I': 0.8, 'X': 0.2})
     b = cirq.asymmetric_depolarize(error_probabilities={'II': 0.8, 'XX': 0.2})
 
@@ -845,13 +845,13 @@ def test_multi_asymmetric_depolarizing_eq():
     assert not cirq.approx_eq(a, cirq.X)
 
 
-def test_multi_asymmetric_depolarizing_channel_str():
+def test_multi_asymmetric_depolarizing_channel_str() -> None:
     assert str(cirq.asymmetric_depolarize(error_probabilities={'II': 0.8, 'XX': 0.2})) == (
         "asymmetric_depolarize(error_probabilities={'II': 0.8, 'XX': 0.2})"
     )
 
 
-def test_multi_asymmetric_depolarizing_channel_text_diagram():
+def test_multi_asymmetric_depolarizing_channel_text_diagram() -> None:
     a = cirq.asymmetric_depolarize(error_probabilities={'II': 2 / 3, 'XX': 1 / 3})
     assert cirq.circuit_diagram_info(a, args=no_precision) == cirq.CircuitDiagramInfo(
         wire_symbols=('A(II:0.6666666666666666, XX:0.3333333333333333)', '(1)')
@@ -867,5 +867,5 @@ def test_multi_asymmetric_depolarizing_channel_text_diagram():
     )
 
 
-def test_reset_stabilizer():
+def test_reset_stabilizer() -> None:
     assert cirq.has_stabilizer_effect(cirq.reset(cirq.LineQubit(0)))