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

cirq/protocols/qasm_test.py

@@ -40,7 +40,7 @@ class ExpectsArgsQubits:
         return 'text'
 
 
-def test_qasm():
+def test_qasm() -> None:
     assert cirq.qasm(NoMethod(), default=None) is None
     assert cirq.qasm(NoMethod(), default=5) == 5
     assert cirq.qasm(ReturnsText()) == 'text'
@@ -54,12 +54,12 @@ def test_qasm():
     assert cirq.qasm(ExpectsArgsQubits(), args=cirq.QasmArgs(), qubits=()) == 'text'
 
 
-def test_qasm_qubits_improperly_supplied():
+def test_qasm_qubits_improperly_supplied() -> None:
     with pytest.raises(TypeError, match="does not expect qubits or args to be specified"):
         _ = cirq.qasm(cirq.Circuit(), qubits=[cirq.LineQubit(1)])
 
 
-def test_qasm_args_formatting():
+def test_qasm_args_formatting() -> None:
     args = cirq.QasmArgs()
     assert args.format_field(0.01, '') == '0.01'
     assert args.format_field(0.01, 'half_turns') == 'pi*0.01'

cirq/protocols/qid_shape_protocol_test.py

@@ -17,7 +17,7 @@ import pytest
 import cirq
 
 
-def test_qid_shape():
+def test_qid_shape() -> None:
     class ShapeObj:
         def _qid_shape_(self):
             return (1, 2, 3)

cirq/protocols/resolve_parameters_test.py

@@ -20,7 +20,7 @@ from cirq.study import ParamResolver
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve_parameters(resolve_fn):
+def test_resolve_parameters(resolve_fn) -> None:
     class NoMethod:
         pass
 
@@ -74,7 +74,7 @@ def test_resolve_parameters(resolve_fn):
     assert resolve_fn(1j, resolver) == 1j
 
 
-def test_is_parameterized():
+def test_is_parameterized() -> None:
     a, b = tuple(sympy.Symbol(l) for l in 'ab')
     x, y = 0, 4
     assert not cirq.is_parameterized((x, y))
@@ -90,7 +90,7 @@ def test_is_parameterized():
     assert not cirq.is_parameterized(1j)
 
 
-def test_parameter_names():
+def test_parameter_names() -> None:
     a, b, c = tuple(sympy.Symbol(l) for l in 'abc')
     x, y, z = 0, 4, 7
     assert cirq.parameter_names((a, b, c)) == {'a', 'b', 'c'}
@@ -105,7 +105,7 @@ def test_parameter_names():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_skips_empty_resolution(resolve_fn):
+def test_skips_empty_resolution(resolve_fn) -> None:
     class Tester:
         def _resolve_parameters_(self, resolver, recursive):
             return 5
@@ -115,7 +115,7 @@ def test_skips_empty_resolution(resolve_fn):
     assert resolve_fn(t, {'x': 2}) == 5
 
 
-def test_recursive_resolve():
+def test_recursive_resolve() -> None:
     a, b, c = [sympy.Symbol(l) for l in 'abc']
     resolver = cirq.ParamResolver({a: b + 3, b: c + 2, c: 1})
     assert cirq.resolve_parameters_once(a, resolver) == b + 3

cirq/protocols/trace_distance_bound_test.py

@@ -17,7 +17,7 @@ import numpy as np
 import cirq
 
 
-def test_trace_distance_bound():
+def test_trace_distance_bound() -> None:
     class NoMethod:
         pass
 

cirq/qis/channels_test.py

@@ -65,7 +65,7 @@ def compute_choi(channel: cirq.SupportsKraus) -> np.ndarray:
         ),
     ),
 )
-def test_kraus_to_choi(kraus_operators, expected_choi):
+def test_kraus_to_choi(kraus_operators, expected_choi) -> None:
     """Verifies that cirq.kraus_to_choi computes the correct Choi matrix."""
     assert np.allclose(cirq.kraus_to_choi(kraus_operators), expected_choi)
 
@@ -89,7 +89,7 @@ def test_kraus_to_choi(kraus_operators, expected_choi):
         ),
     ),
 )
-def test_choi_to_kraus_invalid_input(choi, error):
+def test_choi_to_kraus_invalid_input(choi, error) -> None:
     with pytest.raises(ValueError, match=error):
         _ = cirq.choi_to_kraus(choi)
 
@@ -143,7 +143,7 @@ def test_choi_to_kraus_invalid_input(choi, error):
         ),
     ),
 )
-def test_choi_to_kraus_fixed_values(choi, expected_kraus):
+def test_choi_to_kraus_fixed_values(choi, expected_kraus) -> None:
     """Verifies that cirq.choi_to_kraus gives correct results on a few fixed inputs."""
     actual_kraus = cirq.choi_to_kraus(choi)
     assert len(actual_kraus) == len(expected_kraus)
@@ -178,7 +178,7 @@ def test_choi_to_kraus_fixed_values(choi, expected_kraus):
         ),
     ),
 )
-def test_choi_to_kraus_action_on_operatorial_basis(choi):
+def test_choi_to_kraus_action_on_operatorial_basis(choi) -> None:
     """Verifies that cirq.choi_to_kraus computes a valid Kraus representation."""
     kraus_operators = cirq.choi_to_kraus(choi)
     c = np.reshape(choi, (2, 2, 2, 2))
@@ -217,14 +217,14 @@ def test_choi_to_kraus_action_on_operatorial_basis(choi):
         # fmt: on
     ),
 )
-def test_choi_to_kraus_inverse_of_kraus_to_choi(choi):
+def test_choi_to_kraus_inverse_of_kraus_to_choi(choi) -> None:
     """Verifies that cirq.kraus_to_choi(cirq.choi_to_kraus(.)) is identity on Choi matrices."""
     kraus = cirq.choi_to_kraus(choi)
     recovered_choi = cirq.kraus_to_choi(kraus)
     assert np.allclose(recovered_choi, choi)
 
 
-def test_choi_to_kraus_atol():
+def test_choi_to_kraus_atol() -> None:
     """Verifies that insignificant Kraus operators are omitted."""
     choi = cirq.kraus_to_choi(cirq.kraus(cirq.phase_damp(1e-6)))
     assert len(cirq.choi_to_kraus(choi, atol=1e-2)) == 1
@@ -242,7 +242,7 @@ def test_choi_to_kraus_atol():
         cirq.amplitude_damp(0.2),
     ),
 )
-def test_operation_to_choi(channel):
+def test_operation_to_choi(channel) -> None:
     """Verifies that cirq.operation_to_choi correctly computes the Choi matrix."""
     n_qubits = cirq.num_qubits(channel)
     actual = cirq.operation_to_choi(channel)
@@ -251,7 +251,7 @@ def test_operation_to_choi(channel):
     assert np.all(actual == expected)
 
 
-def test_choi_for_completely_dephasing_channel():
+def test_choi_for_completely_dephasing_channel() -> None:
     """Checks cirq.operation_to_choi on the completely dephasing channel."""
     assert np.all(cirq.operation_to_choi(cirq.phase_damp(1)) == np.diag([1, 0, 0, 1]))
 
@@ -268,7 +268,7 @@ def test_choi_for_completely_dephasing_channel():
         ),
     ),
 )
-def test_superoperator_to_kraus_fixed_values(superoperator, expected_kraus_operators):
+def test_superoperator_to_kraus_fixed_values(superoperator, expected_kraus_operators) -> None:
     """Verifies that cirq.kraus_to_superoperator computes the correct channel matrix."""
     actual_kraus_operators = cirq.superoperator_to_kraus(superoperator)
     for i in (0, 1):
@@ -306,14 +306,14 @@ def test_superoperator_to_kraus_fixed_values(superoperator, expected_kraus_opera
         # fmt: on
     ),
 )
-def test_superoperator_to_kraus_inverse_of_kraus_to_superoperator(superoperator):
+def test_superoperator_to_kraus_inverse_of_kraus_to_superoperator(superoperator) -> None:
     """Verifies that cirq.kraus_to_superoperator(cirq.superoperator_to_kraus(.)) is identity."""
     kraus = cirq.superoperator_to_kraus(superoperator)
     recovered_superoperator = cirq.kraus_to_superoperator(kraus)
     assert np.allclose(recovered_superoperator, superoperator)
 
 
-def test_superoperator_to_kraus_atol():
+def test_superoperator_to_kraus_atol() -> None:
     """Verifies that insignificant Kraus operators are omitted."""
     superop = cirq.kraus_to_superoperator(cirq.kraus(cirq.phase_damp(1e-6)))
     assert len(cirq.superoperator_to_kraus(superop, atol=1e-2)) == 1
@@ -338,7 +338,7 @@ def test_superoperator_to_kraus_atol():
         ),
     ),
 )
-def test_choi_to_superoperator_invalid_input(choi, error):
+def test_choi_to_superoperator_invalid_input(choi, error) -> None:
     with pytest.raises(ValueError, match=error):
         _ = cirq.choi_to_superoperator(choi)
 
@@ -346,7 +346,7 @@ def test_choi_to_superoperator_invalid_input(choi, error):
 @pytest.mark.parametrize(
     'superoperator, error', ((np.array([[1, 2, 3], [4, 5, 6]]), "shape"), (np.eye(2), "shape"))
 )
-def test_superoperator_to_choi_invalid_input(superoperator, error):
+def test_superoperator_to_choi_invalid_input(superoperator, error) -> None:
     with pytest.raises(ValueError, match=error):
         _ = cirq.superoperator_to_choi(superoperator)
 
@@ -402,7 +402,7 @@ def test_superoperator_to_choi_invalid_input(superoperator, error):
         ),
     ),
 )
-def test_superoperator_vs_choi_fixed_values(superoperator, choi):
+def test_superoperator_vs_choi_fixed_values(superoperator, choi) -> None:
     recovered_choi = cirq.superoperator_to_choi(superoperator)
     assert np.allclose(recovered_choi, choi)
 
@@ -436,7 +436,7 @@ def test_superoperator_vs_choi_fixed_values(superoperator, choi):
         # fmt: on
     ),
 )
-def test_choi_to_superoperator_inverse_of_superoperator_to_choi(choi):
+def test_choi_to_superoperator_inverse_of_superoperator_to_choi(choi) -> None:
     superoperator = cirq.choi_to_superoperator(choi)
     recovered_choi = cirq.superoperator_to_choi(superoperator)
     assert np.allclose(recovered_choi, choi)
@@ -445,6 +445,6 @@ def test_choi_to_superoperator_inverse_of_superoperator_to_choi(choi):
     assert np.allclose(recovered_superoperator, superoperator)
 
 
-def test_superoperator_for_completely_dephasing_channel():
+def test_superoperator_for_completely_dephasing_channel() -> None:
     """Checks cirq.operation_to_superoperator on the completely dephasing channel."""
     assert np.all(cirq.operation_to_superoperator(cirq.phase_damp(1)) == np.diag([1, 0, 0, 1]))

cirq/qis/measures_test.py

@@ -25,7 +25,7 @@ MAT2 = cirq.testing.random_density_matrix(N)
 U = cirq.testing.random_unitary(N)
 
 
-def test_fidelity_symmetric():
+def test_fidelity_symmetric() -> None:
     np.testing.assert_allclose(cirq.fidelity(VEC1, VEC2), cirq.fidelity(VEC2, VEC1))
     np.testing.assert_allclose(cirq.fidelity(VEC1, MAT1), cirq.fidelity(MAT1, VEC1))
     np.testing.assert_allclose(
@@ -34,27 +34,27 @@ def test_fidelity_symmetric():
     )
 
 
-def test_bad_fidelity():
+def test_bad_fidelity() -> None:
     arr = np.asarray([[[1j, 0], [0, 0]], [[0, 0], [0, 0]]])
     assert arr.ndim > 2
     assert arr.dtype.kind == 'c'
     _ = cirq.fidelity(arr, arr)
 
 
-def test_fidelity_between_zero_and_one():
+def test_fidelity_between_zero_and_one() -> None:
     assert 0 <= cirq.fidelity(VEC1, VEC2) <= 1
     assert 0 <= cirq.fidelity(VEC1, MAT1) <= 1
     assert 0 <= cirq.fidelity(cirq.density_matrix(MAT1), MAT2) <= 1
 
 
-def test_fidelity_invariant_under_unitary_transformation():
+def test_fidelity_invariant_under_unitary_transformation() -> None:
     np.testing.assert_allclose(
         cirq.fidelity(cirq.density_matrix(MAT1), MAT2),
         cirq.fidelity(cirq.density_matrix(U @ MAT1 @ U.T.conj()), U @ MAT2 @ U.T.conj()),
     )
 
 
-def test_fidelity_commuting_matrices():
+def test_fidelity_commuting_matrices() -> None:
     d1 = np.random.uniform(size=N)
     d1 /= np.sum(d1)
     d2 = np.random.uniform(size=N)
@@ -67,7 +67,7 @@ def test_fidelity_commuting_matrices():
     )
 
 
-def test_fidelity_known_values():
+def test_fidelity_known_values() -> None:
     vec1 = np.array([1, 1j, -1, -1j]) * 0.5
     vec2 = np.array([1, -1, 1, -1], dtype=np.complex128) * 0.5
     vec3 = np.array([1, 0, 0, 0], dtype=np.complex128)
@@ -94,7 +94,7 @@ def test_fidelity_known_values():
     np.testing.assert_allclose(cirq.fidelity(mat3, vec2), 0.7)
 
 
-def test_fidelity_numpy_arrays():
+def test_fidelity_numpy_arrays() -> None:
     vec1 = np.array([1, 0, 0, 0, 0, 0, 0, 0], dtype=np.complex64)
     vec2 = np.array([1, 0, 0, 0], dtype=np.complex64)
     tensor1 = np.reshape(vec1, (2, 2, 2))
@@ -122,7 +122,7 @@ def test_fidelity_numpy_arrays():
         _ = cirq.fidelity(mat1, mat1)
 
 
-def test_fidelity_ints():
+def test_fidelity_ints() -> None:
     assert cirq.fidelity(3, 4) == 0.0
     assert cirq.fidelity(4, 4) == 1.0
 
@@ -134,7 +134,7 @@ def test_fidelity_ints():
         _ = cirq.fidelity(1, 4, qid_shape=(2,))
 
 
-def test_fidelity_product_states():
+def test_fidelity_product_states() -> None:
     a, b = cirq.LineQubit.range(2)
 
     np.testing.assert_allclose(
@@ -171,19 +171,19 @@ def test_fidelity_product_states():
         )
 
 
-def test_fidelity_fail_inference():
+def test_fidelity_fail_inference() -> None:
     state_vector = cirq.one_hot(shape=(4,), dtype=np.complex128)
     state_tensor = np.reshape(state_vector, (2, 2))
     with pytest.raises(ValueError, match='Please specify'):
         _ = cirq.fidelity(state_tensor, 4)
 
 
-def test_fidelity_bad_shape():
+def test_fidelity_bad_shape() -> None:
     with pytest.raises(ValueError, match='Invalid quantum state'):
         _ = cirq.fidelity(np.array([[[1.0]]]), np.array([[[1.0]]]), qid_shape=(1,))
 
 
-def test_von_neumann_entropy():
+def test_von_neumann_entropy() -> None:
     # 1x1 matrix
     assert cirq.von_neumann_entropy(np.array([[1]])) == 0
     # An EPR pair state (|00> + |11>)(<00| + <11|)
@@ -243,7 +243,7 @@ def test_von_neumann_entropy():
         (cirq.TOFFOLI, 9 / 16),
     ),
 )
-def test_entanglement_fidelity_of_unitary_channels(gate, expected_entanglement_fidelity):
+def test_entanglement_fidelity_of_unitary_channels(gate, expected_entanglement_fidelity) -> None:
     assert np.isclose(cirq.entanglement_fidelity(gate), expected_entanglement_fidelity)
 
 
@@ -261,7 +261,9 @@ def test_entanglement_fidelity_of_unitary_channels(gate, expected_entanglement_f
         (cirq.amplitude_damp, lambda gamma: 1 / 2 - gamma / 4 + np.sqrt(1 - gamma) / 2),
     ),
 )
-def test_entanglement_fidelity_of_noisy_channels(p, channel_factory, entanglement_fidelity_formula):
+def test_entanglement_fidelity_of_noisy_channels(
+    p, channel_factory, entanglement_fidelity_formula
+) -> None:
     channel = channel_factory(p)
     actual_entanglement_fidelity = cirq.entanglement_fidelity(channel)
     expected_entanglement_fidelity = entanglement_fidelity_formula(p)

cirq/qis/noise_utils_test.py

@@ -30,7 +30,7 @@ from cirq.qis.noise_utils import (
     'decay_constant,num_qubits,expected_output',
     [(0.01, 1, 1 - (0.99 * 1 / 2)), (0.05, 2, 1 - (0.95 * 3 / 4))],
 )
-def test_decay_constant_to_xeb_fidelity(decay_constant, num_qubits, expected_output):
+def test_decay_constant_to_xeb_fidelity(decay_constant, num_qubits, expected_output) -> None:
     val = decay_constant_to_xeb_fidelity(decay_constant, num_qubits)
     assert val == expected_output
 
@@ -39,7 +39,7 @@ def test_decay_constant_to_xeb_fidelity(decay_constant, num_qubits, expected_out
     'decay_constant,num_qubits,expected_output',
     [(0.01, 1, 0.99 * 3 / 4), (0.05, 2, 0.95 * 15 / 16)],
 )
-def test_decay_constant_to_pauli_error(decay_constant, num_qubits, expected_output):
+def test_decay_constant_to_pauli_error(decay_constant, num_qubits, expected_output) -> None:
     val = decay_constant_to_pauli_error(decay_constant, num_qubits)
     assert val == expected_output
 
@@ -48,7 +48,7 @@ def test_decay_constant_to_pauli_error(decay_constant, num_qubits, expected_outp
     'pauli_error,num_qubits,expected_output',
     [(0.01, 1, 1 - (0.01 / (3 / 4))), (0.05, 2, 1 - (0.05 / (15 / 16)))],
 )
-def test_pauli_error_to_decay_constant(pauli_error, num_qubits, expected_output):
+def test_pauli_error_to_decay_constant(pauli_error, num_qubits, expected_output) -> None:
     val = pauli_error_to_decay_constant(pauli_error, num_qubits)
     assert val == expected_output
 
@@ -57,7 +57,7 @@ def test_pauli_error_to_decay_constant(pauli_error, num_qubits, expected_output)
     'xeb_fidelity,num_qubits,expected_output',
     [(0.01, 1, 1 - 0.99 / (1 / 2)), (0.05, 2, 1 - 0.95 / (3 / 4))],
 )
-def test_xeb_fidelity_to_decay_constant(xeb_fidelity, num_qubits, expected_output):
+def test_xeb_fidelity_to_decay_constant(xeb_fidelity, num_qubits, expected_output) -> None:
     val = xeb_fidelity_to_decay_constant(xeb_fidelity, num_qubits)
     assert val == expected_output
 
@@ -69,7 +69,7 @@ def test_xeb_fidelity_to_decay_constant(xeb_fidelity, num_qubits, expected_outpu
         (4000, 1e4, (1 - np.exp(-4000 / 2e4)) / 2 + (1 - np.exp(-4000 / 1e4)) / 4),
     ],
 )
-def test_pauli_error_from_t1(t, t1_ns, expected_output):
+def test_pauli_error_from_t1(t, t1_ns, expected_output) -> None:
     val = pauli_error_from_t1(t, t1_ns)
     assert val == expected_output
 
@@ -77,7 +77,7 @@ def test_pauli_error_from_t1(t, t1_ns, expected_output):
 @pytest.mark.parametrize(
     'decay_constant,num_qubits,expected_output', [(0.01, 1, 0.99 * 1 / 2), (0.05, 2, 0.95 * 3 / 4)]
 )
-def test_average_error(decay_constant, num_qubits, expected_output):
+def test_average_error(decay_constant, num_qubits, expected_output) -> None:
     val = average_error(decay_constant, num_qubits)
     assert val == expected_output
 
@@ -85,7 +85,7 @@ def test_average_error(decay_constant, num_qubits, expected_output):
 @pytest.mark.parametrize(
     'T1_ns,Tphi_ns,gate_time_ns', [(1e4, 2e4, 25), (1e5, 2e3, 25), (1e4, 2e4, 4000)]
 )
-def test_decoherence_pauli_error(T1_ns, Tphi_ns, gate_time_ns):
+def test_decoherence_pauli_error(T1_ns, Tphi_ns, gate_time_ns) -> None:
     val = decoherence_pauli_error(T1_ns, Tphi_ns, gate_time_ns)
     # Expected value is of the form:
     #

cirq/sim/clifford/clifford_tableau_simulation_state_test.py

@@ -20,7 +20,7 @@ import pytest
 import cirq
 
 
-def test_unitary_fallback():
+def test_unitary_fallback() -> None:
     class UnitaryXGate(cirq.testing.SingleQubitGate):
         def _unitary_(self):
             return np.array([[0, 1], [1, 0]])
@@ -57,7 +57,7 @@ def test_unitary_fallback():
     assert args.tableau == expected_args.tableau
 
 
-def test_cannot_act():
+def test_cannot_act() -> None:
     class NoDetails:
         pass
 
@@ -77,7 +77,7 @@ def test_cannot_act():
         cirq.act_on(NoDetailsSingleQubitGate(), args, [cirq.LineQubit(1)])
 
 
-def test_copy():
+def test_copy() -> None:
     args = cirq.CliffordTableauSimulationState(
         tableau=cirq.CliffordTableau(num_qubits=3),
         qubits=cirq.LineQubit.range(3),

cirq/sim/clifford/stabilizer_ch_form_simulation_state_test.py

@@ -18,14 +18,14 @@ import pytest
 import cirq
 
 
-def test_init_state():
+def test_init_state() -> None:
     args = cirq.StabilizerChFormSimulationState(qubits=cirq.LineQubit.range(1), initial_state=1)
     np.testing.assert_allclose(args.state.state_vector(), [0, 1])
     with pytest.raises(ValueError, match='Must specify qubits'):
         _ = cirq.StabilizerChFormSimulationState(initial_state=1)
 
 
-def test_cannot_act():
+def test_cannot_act() -> None:
     class NoDetails(cirq.testing.SingleQubitGate):
         pass
 
@@ -35,7 +35,7 @@ def test_cannot_act():
         cirq.act_on(NoDetails(), args, qubits=())
 
 
-def test_gate_with_act_on():
+def test_gate_with_act_on() -> None:
     class CustomGate(cirq.testing.SingleQubitGate):
         def _act_on_(self, sim_state, qubits):
             if isinstance(sim_state, cirq.StabilizerChFormSimulationState):
@@ -53,7 +53,7 @@ def test_gate_with_act_on():
     np.testing.assert_allclose(state.gamma, [0, 1, 0])
 
 
-def test_unitary_fallback_y():
+def test_unitary_fallback_y() -> None:
     class UnitaryYGate(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -72,7 +72,7 @@ def test_unitary_fallback_y():
     np.testing.assert_allclose(args.state.state_vector(), expected_args.state.state_vector())
 
 
-def test_unitary_fallback_h():
+def test_unitary_fallback_h() -> None:
     class UnitaryHGate(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -91,7 +91,7 @@ def test_unitary_fallback_h():
     np.testing.assert_allclose(args.state.state_vector(), expected_args.state.state_vector())
 
 
-def test_copy():
+def test_copy() -> None:
     args = cirq.StabilizerChFormSimulationState(
         qubits=cirq.LineQubit.range(3), prng=np.random.RandomState()
     )

cirq/sim/clifford/stabilizer_sampler_test.py

@@ -17,7 +17,7 @@ import numpy as np
 import cirq
 
 
-def test_produces_samples():
+def test_produces_samples() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.H(a), cirq.CNOT(a, b), cirq.measure(a, key='a'), cirq.measure(b, key='b'))
 
@@ -26,7 +26,7 @@ def test_produces_samples():
     assert np.all(result['a'] ^ result['b'] == 0)
 
 
-def test_reset():
+def test_reset() -> None:
     q = cirq.LineQubit(0)
     sampler = cirq.StabilizerSampler()
     c = cirq.Circuit(cirq.X(q), cirq.reset(q), cirq.measure(q))

cirq/sim/clifford/stabilizer_simulation_state_test.py

@@ -20,7 +20,7 @@ import sympy
 import cirq
 
 
-def test_apply_gate():
+def test_apply_gate() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     state = mock.Mock()
     args = cirq.StabilizerSimulationState(state=state, qubits=[q0, q1])
@@ -89,7 +89,7 @@ def test_apply_gate():
     state.apply_x.assert_not_called()
 
 
-def test_apply_mixture():
+def test_apply_mixture() -> None:
     q0 = cirq.LineQubit(0)
     state = mock.Mock()
     args = cirq.StabilizerSimulationState(state=state, qubits=[q0])
@@ -100,7 +100,7 @@ def test_apply_mixture():
     assert 10 < state.apply_x.call_count < 90
 
 
-def test_act_from_single_qubit_decompose():
+def test_act_from_single_qubit_decompose() -> None:
     q0 = cirq.LineQubit(0)
     state = mock.Mock()
     args = cirq.StabilizerSimulationState(state=state, qubits=[q0])
@@ -113,7 +113,7 @@ def test_act_from_single_qubit_decompose():
     state.apply_x.assert_called_with(0, 1.0, 0.0)
 
 
-def test_decompose():
+def test_decompose() -> None:
     class XContainer(cirq.Gate):
         def _decompose_(self, qs):
             return [cirq.X(*qs)]

cirq/sim/clifford/stabilizer_state_ch_form_test.py

@@ -22,7 +22,7 @@ import cirq.testing
 # Github issue: https://github.com/quantumlib/Cirq/issues/3021
 
 
-def test_initial_state():
+def test_initial_state() -> None:
     with pytest.raises(ValueError, match='Out of range'):
         _ = cirq.StabilizerStateChForm(initial_state=-31, num_qubits=5)
     with pytest.raises(ValueError, match='Out of range'):
@@ -33,7 +33,7 @@ def test_initial_state():
     np.testing.assert_allclose(state.state_vector(), expected_state_vector)
 
 
-def test_run():
+def test_run() -> None:
     (q0, q1, q2) = (cirq.LineQubit(0), cirq.LineQubit(1), cirq.LineQubit(2))
 
     """

cirq/sim/density_matrix_simulation_state_test.py

@@ -18,7 +18,7 @@ import pytest
 import cirq
 
 
-def test_default_parameter():
+def test_default_parameter() -> None:
     qid_shape = (2,)
     tensor = cirq.to_valid_density_matrix(
         0, len(qid_shape), qid_shape=qid_shape, dtype=np.complex64
@@ -32,13 +32,13 @@ def test_default_parameter():
     assert args.qid_shape == qid_shape
 
 
-def test_shallow_copy_buffers():
+def test_shallow_copy_buffers() -> None:
     args = cirq.DensityMatrixSimulationState(qubits=cirq.LineQubit.range(1), initial_state=0)
     copy = args.copy(deep_copy_buffers=False)
     assert copy.available_buffer is args.available_buffer
 
 
-def test_decomposed_fallback():
+def test_decomposed_fallback() -> None:
     class Composite(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -59,7 +59,7 @@ def test_decomposed_fallback():
     )
 
 
-def test_cannot_act():
+def test_cannot_act() -> None:
     class NoDetails:
         pass
 
@@ -73,12 +73,12 @@ def test_cannot_act():
         cirq.act_on(NoDetails(), args, qubits=())
 
 
-def test_qid_shape_error():
+def test_qid_shape_error() -> None:
     with pytest.raises(ValueError, match="qid_shape must be provided"):
         cirq.sim.density_matrix_simulation_state._BufferedDensityMatrix.create(initial_state=0)
 
 
-def test_initial_state_vector():
+def test_initial_state_vector() -> None:
     qubits = cirq.LineQubit.range(3)
     args = cirq.DensityMatrixSimulationState(
         qubits=qubits, initial_state=np.full((8,), 1 / np.sqrt(8)), dtype=np.complex64
@@ -91,7 +91,7 @@ def test_initial_state_vector():
     assert args2.target_tensor.shape == (2, 2, 2, 2, 2, 2)
 
 
-def test_initial_state_matrix():
+def test_initial_state_matrix() -> None:
     qubits = cirq.LineQubit.range(3)
     args = cirq.DensityMatrixSimulationState(
         qubits=qubits, initial_state=np.full((8, 8), 1 / 8), dtype=np.complex64
@@ -104,7 +104,7 @@ def test_initial_state_matrix():
     assert args2.target_tensor.shape == (2, 2, 2, 2, 2, 2)
 
 
-def test_initial_state_bad_shape():
+def test_initial_state_bad_shape() -> None:
     qubits = cirq.LineQubit.range(3)
     with pytest.raises(ValueError, match="Invalid quantum state"):
         cirq.DensityMatrixSimulationState(