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

cirq/sim/density_matrix_utils_test.py

@@ -21,7 +21,7 @@ import cirq
 import cirq.testing
 
 
-def test_sample_density_matrix_big_endian():
+def test_sample_density_matrix_big_endian() -> None:
     results = []
     for x in range(8):
         matrix = cirq.to_valid_density_matrix(x, 3)
@@ -32,7 +32,7 @@ def test_sample_density_matrix_big_endian():
         np.testing.assert_equal(result, expected)
 
 
-def test_sample_density_matrix_partial_indices():
+def test_sample_density_matrix_partial_indices() -> None:
     for index in range(3):
         for x in range(8):
             matrix = cirq.to_valid_density_matrix(x, 3)
@@ -41,14 +41,14 @@ def test_sample_density_matrix_partial_indices():
             )
 
 
-def test_sample_density_matrix_partial_indices_oder():
+def test_sample_density_matrix_partial_indices_oder() -> None:
     for x in range(8):
         matrix = cirq.to_valid_density_matrix(x, 3)
         expected = [[bool(1 & (x >> 0)), bool(1 & (x >> 1))]]
         np.testing.assert_equal(cirq.sample_density_matrix(matrix, [2, 1]), expected)
 
 
-def test_sample_density_matrix_partial_indices_all_orders():
+def test_sample_density_matrix_partial_indices_all_orders() -> None:
     for perm in itertools.permutations([0, 1, 2]):
         for x in range(8):
             matrix = cirq.to_valid_density_matrix(x, 3)
@@ -56,7 +56,7 @@ def test_sample_density_matrix_partial_indices_all_orders():
             np.testing.assert_equal(cirq.sample_density_matrix(matrix, perm), expected)
 
 
-def test_sample_density_matrix():
+def test_sample_density_matrix() -> None:
     state = np.zeros(8, dtype=np.complex64)
     state[0] = 1 / np.sqrt(2)
     state[2] = 1 / np.sqrt(2)
@@ -72,7 +72,7 @@ def test_sample_density_matrix():
         np.testing.assert_equal(cirq.sample_density_matrix(matrix, [0]), [[False]])
 
 
-def test_sample_density_matrix_seed():
+def test_sample_density_matrix_seed() -> None:
     density_matrix = 0.5 * np.eye(2)
 
     samples = cirq.sample_density_matrix(density_matrix, [0], repetitions=10, seed=1234)
@@ -90,12 +90,12 @@ def test_sample_density_matrix_seed():
     )
 
 
-def test_sample_empty_density_matrix():
+def test_sample_empty_density_matrix() -> None:
     matrix = np.zeros(shape=())
     np.testing.assert_almost_equal(cirq.sample_density_matrix(matrix, []), [[]])
 
 
-def test_sample_density_matrix_no_repetitions():
+def test_sample_density_matrix_no_repetitions() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     np.testing.assert_almost_equal(
         cirq.sample_density_matrix(matrix, [1], repetitions=0), np.zeros(shape=(0, 1))
@@ -105,7 +105,7 @@ def test_sample_density_matrix_no_repetitions():
     )
 
 
-def test_sample_density_matrix_repetitions():
+def test_sample_density_matrix_repetitions() -> None:
     for perm in itertools.permutations([0, 1, 2]):
         for x in range(8):
             matrix = cirq.to_valid_density_matrix(x, 3)
@@ -115,30 +115,30 @@ def test_sample_density_matrix_repetitions():
             np.testing.assert_equal(result, expected)
 
 
-def test_sample_density_matrix_negative_repetitions():
+def test_sample_density_matrix_negative_repetitions() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     with pytest.raises(ValueError, match='-1'):
         cirq.sample_density_matrix(matrix, [1], repetitions=-1)
 
 
-def test_sample_density_matrix_not_square():
+def test_sample_density_matrix_not_square() -> None:
     with pytest.raises(ValueError, match='not square'):
         cirq.sample_density_matrix(np.array([1, 0, 0]), [1])
 
 
-def test_sample_density_matrix_not_power_of_two():
+def test_sample_density_matrix_not_power_of_two() -> None:
     with pytest.raises(ValueError, match='power of two'):
         cirq.sample_density_matrix(np.ones((3, 3)) / 3, [1])
     with pytest.raises(ValueError, match='power of two'):
         cirq.sample_density_matrix(np.ones((2, 3, 2, 3)) / 6, [1])
 
 
-def test_sample_density_matrix_higher_powers_of_two():
+def test_sample_density_matrix_higher_powers_of_two() -> None:
     with pytest.raises(ValueError, match='powers of two'):
         cirq.sample_density_matrix(np.ones((2, 4, 2, 4)) / 8, [1])
 
 
-def test_sample_density_matrix_out_of_range():
+def test_sample_density_matrix_out_of_range() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     with pytest.raises(IndexError, match='-2'):
         cirq.sample_density_matrix(matrix, [-2])
@@ -146,13 +146,13 @@ def test_sample_density_matrix_out_of_range():
         cirq.sample_density_matrix(matrix, [3])
 
 
-def test_sample_density_matrix_no_indices():
+def test_sample_density_matrix_no_indices() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     bits = cirq.sample_density_matrix(matrix, [])
     np.testing.assert_almost_equal(bits, np.zeros(shape=(1, 0)))
 
 
-def test_sample_density_matrix_validate_qid_shape():
+def test_sample_density_matrix_validate_qid_shape() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     cirq.sample_density_matrix(matrix, [], qid_shape=(2, 2, 2))
     with pytest.raises(ValueError, match='Matrix size does not match qid shape'):
@@ -163,7 +163,7 @@ def test_sample_density_matrix_validate_qid_shape():
         cirq.sample_density_matrix(matrix2, [], qid_shape=(2, 2, 2))
 
 
-def test_measure_density_matrix_computational_basis():
+def test_measure_density_matrix_computational_basis() -> None:
     results = []
     for x in range(8):
         matrix = cirq.to_valid_density_matrix(x, 3)
@@ -174,7 +174,7 @@ def test_measure_density_matrix_computational_basis():
     assert results == expected
 
 
-def test_measure_density_matrix_computational_basis_reversed():
+def test_measure_density_matrix_computational_basis_reversed() -> None:
     results = []
     for x in range(8):
         matrix = cirq.to_valid_density_matrix(x, 3)
@@ -185,7 +185,7 @@ def test_measure_density_matrix_computational_basis_reversed():
     assert results == expected
 
 
-def test_measure_density_matrix_computational_basis_reshaped():
+def test_measure_density_matrix_computational_basis_reshaped() -> None:
     results = []
     for x in range(8):
         matrix = np.reshape(cirq.to_valid_density_matrix(x, 3), (2,) * 6)
@@ -196,7 +196,7 @@ def test_measure_density_matrix_computational_basis_reshaped():
     assert results == expected
 
 
-def test_measure_density_matrix_partial_indices():
+def test_measure_density_matrix_partial_indices() -> None:
     for index in range(3):
         for x in range(8):
             matrix = cirq.to_valid_density_matrix(x, 3)
@@ -205,7 +205,7 @@ def test_measure_density_matrix_partial_indices():
             assert bits == [bool(1 & (x >> (2 - index)))]
 
 
-def test_measure_density_matrix_partial_indices_all_orders():
+def test_measure_density_matrix_partial_indices_all_orders() -> None:
     for perm in itertools.permutations([0, 1, 2]):
         for x in range(8):
             matrix = cirq.to_valid_density_matrix(x, 3)
@@ -221,7 +221,7 @@ def matrix_000_plus_010():
     return cirq.to_valid_density_matrix(state, num_qubits=3)
 
 
-def test_measure_density_matrix_collapse():
+def test_measure_density_matrix_collapse() -> None:
     matrix = matrix_000_plus_010()
     for _ in range(10):
         bits, out_matrix = cirq.measure_density_matrix(matrix, [2, 1, 0])
@@ -246,7 +246,7 @@ def test_measure_density_matrix_collapse():
         assert bits == [False]
 
 
-def test_measure_density_matrix_seed():
+def test_measure_density_matrix_seed() -> None:
     n = 5
     matrix = np.eye(2**n) / 2**n
 
@@ -261,7 +261,7 @@ def test_measure_density_matrix_seed():
     np.testing.assert_allclose(out_matrix1, out_matrix2)
 
 
-def test_measure_density_matrix_out_is_matrix():
+def test_measure_density_matrix_out_is_matrix() -> None:
     matrix = matrix_000_plus_010()
     bits, out_matrix = cirq.measure_density_matrix(matrix, [2, 1, 0], out=matrix)
     expected_state = np.zeros(8, dtype=np.complex64)
@@ -271,7 +271,7 @@ def test_measure_density_matrix_out_is_matrix():
     assert out_matrix is matrix
 
 
-def test_measure_state_out_is_not_matrix():
+def test_measure_state_out_is_not_matrix() -> None:
     matrix = matrix_000_plus_010()
     out = np.zeros_like(matrix)
     _, out_matrix = cirq.measure_density_matrix(matrix, [2, 1, 0], out=out)
@@ -279,7 +279,7 @@ def test_measure_state_out_is_not_matrix():
     assert out is out_matrix
 
 
-def test_measure_density_matrix_not_square():
+def test_measure_density_matrix_not_square() -> None:
     with pytest.raises(ValueError, match='not square'):
         cirq.measure_density_matrix(np.array([1, 0, 0]), [1])
     with pytest.raises(ValueError, match='not square'):
@@ -288,26 +288,26 @@ def test_measure_density_matrix_not_square():
         )
 
 
-def test_measure_density_matrix_not_power_of_two():
+def test_measure_density_matrix_not_power_of_two() -> None:
     with pytest.raises(ValueError, match='power of two'):
         cirq.measure_density_matrix(np.ones((3, 3)) / 3, [1])
     with pytest.raises(ValueError, match='power of two'):
         cirq.measure_density_matrix(np.ones((2, 3, 2, 3)) / 6, [1])
 
 
-def test_measure_density_matrix_higher_powers_of_two():
+def test_measure_density_matrix_higher_powers_of_two() -> None:
     with pytest.raises(ValueError, match='powers of two'):
         cirq.measure_density_matrix(np.ones((2, 4, 2, 4)) / 8, [1])
 
 
-def test_measure_density_matrix_tensor_different_left_right_shape():
+def test_measure_density_matrix_tensor_different_left_right_shape() -> None:
     with pytest.raises(ValueError, match='not equal'):
         cirq.measure_density_matrix(
             np.array([1, 0, 0, 0]).reshape((2, 2, 1, 1)), [1], qid_shape=(2, 1)
         )
 
 
-def test_measure_density_matrix_out_of_range():
+def test_measure_density_matrix_out_of_range() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     with pytest.raises(IndexError, match='-2'):
         cirq.measure_density_matrix(matrix, [-2])
@@ -315,14 +315,14 @@ def test_measure_density_matrix_out_of_range():
         cirq.measure_density_matrix(matrix, [3])
 
 
-def test_measure_state_no_indices():
+def test_measure_state_no_indices() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     bits, out_matrix = cirq.measure_density_matrix(matrix, [])
     assert [] == bits
     np.testing.assert_almost_equal(out_matrix, matrix)
 
 
-def test_measure_state_no_indices_out_is_matrix():
+def test_measure_state_no_indices_out_is_matrix() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     bits, out_matrix = cirq.measure_density_matrix(matrix, [], out=matrix)
     assert [] == bits
@@ -330,7 +330,7 @@ def test_measure_state_no_indices_out_is_matrix():
     assert out_matrix is matrix
 
 
-def test_measure_state_no_indices_out_is_not_matrix():
+def test_measure_state_no_indices_out_is_not_matrix() -> None:
     matrix = cirq.to_valid_density_matrix(0, 3)
     out = np.zeros_like(matrix)
     bits, out_matrix = cirq.measure_density_matrix(matrix, [], out=out)
@@ -340,7 +340,7 @@ def test_measure_state_no_indices_out_is_not_matrix():
     assert out is not matrix
 
 
-def test_measure_state_empty_density_matrix():
+def test_measure_state_empty_density_matrix() -> None:
     matrix = np.zeros(shape=())
     bits, out_matrix = cirq.measure_density_matrix(matrix, [])
     assert [] == bits
@@ -350,14 +350,14 @@ def test_measure_state_empty_density_matrix():
 @pytest.mark.parametrize('seed', [17, 35, 48])
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])
 @pytest.mark.parametrize('split', [False, True])
-def test_to_valid_density_matrix_on_simulator_output(seed, dtype, split):
+def test_to_valid_density_matrix_on_simulator_output(seed, dtype, split) -> None:
     circuit = cirq.testing.random_circuit(qubits=5, n_moments=20, op_density=0.9, random_state=seed)
     simulator = cirq.DensityMatrixSimulator(split_untangled_states=split, dtype=dtype)
     result = simulator.simulate(circuit)
     _ = cirq.to_valid_density_matrix(result.final_density_matrix, num_qubits=5, atol=1e-6)
 
 
-def test_factor_validation():
+def test_factor_validation() -> None:
     args = cirq.DensityMatrixSimulator()._create_simulation_state(0, qubits=cirq.LineQubit.range(2))
     args.apply_operation(cirq.H(cirq.LineQubit(0)))
     t = args.create_merged_state().target_tensor

cirq/sim/simulation_product_state_test.py

@@ -70,7 +70,7 @@ def create_container(
     )
 
 
-def test_entanglement_causes_join():
+def test_entanglement_causes_join() -> None:
     state = create_container(qs2)
     assert len(set(state.values())) == 3
     state.apply_operation(cirq.CNOT(q0, q1))
@@ -79,7 +79,7 @@ def test_entanglement_causes_join():
     assert state[None] is not state[q0]
 
 
-def test_subcircuit_entanglement_causes_join():
+def test_subcircuit_entanglement_causes_join() -> None:
     state = create_container(qs2)
     assert len(set(state.values())) == 3
     state.apply_operation(cirq.CircuitOperation(cirq.FrozenCircuit(cirq.CNOT(q0, q1))))
@@ -87,7 +87,7 @@ def test_subcircuit_entanglement_causes_join():
     assert state[q0] is state[q1]
 
 
-def test_subcircuit_entanglement_causes_join_in_subset():
+def test_subcircuit_entanglement_causes_join_in_subset() -> None:
     state = create_container(qs3)
     assert len(set(state.values())) == 4
     state.apply_operation(cirq.CircuitOperation(cirq.FrozenCircuit(cirq.CNOT(q0, q1))))
@@ -98,7 +98,7 @@ def test_subcircuit_entanglement_causes_join_in_subset():
     assert state[q0] is state[q1] is state[q2]
 
 
-def test_identity_does_not_join():
+def test_identity_does_not_join() -> None:
     state = create_container(qs2)
     assert len(set(state.values())) == 3
     state.apply_operation(cirq.IdentityGate(2)(q0, q1))
@@ -107,7 +107,7 @@ def test_identity_does_not_join():
     assert state[q0] is not state[None]
 
 
-def test_identity_fallback_does_not_join():
+def test_identity_fallback_does_not_join() -> None:
     state = create_container(qs2)
     assert len(set(state.values())) == 3
     state._act_on_fallback_(cirq.I, (q0, q1))
@@ -116,7 +116,7 @@ def test_identity_fallback_does_not_join():
     assert state[q0] is not state[None]
 
 
-def test_subcircuit_identity_does_not_join():
+def test_subcircuit_identity_does_not_join() -> None:
     state = create_container(qs2)
     assert len(set(state.values())) == 3
     state.apply_operation(cirq.CircuitOperation(cirq.FrozenCircuit(cirq.IdentityGate(2)(q0, q1))))
@@ -124,7 +124,7 @@ def test_subcircuit_identity_does_not_join():
     assert state[q0] is not state[q1]
 
 
-def test_measurement_causes_split():
+def test_measurement_causes_split() -> None:
     state = create_container(qs2)
     state.apply_operation(cirq.CNOT(q0, q1))
     assert len(set(state.values())) == 2
@@ -134,7 +134,7 @@ def test_measurement_causes_split():
     assert state[q0] is not state[None]
 
 
-def test_subcircuit_measurement_causes_split():
+def test_subcircuit_measurement_causes_split() -> None:
     state = create_container(qs2)
     state.apply_operation(cirq.CNOT(q0, q1))
     assert len(set(state.values())) == 2
@@ -143,7 +143,7 @@ def test_subcircuit_measurement_causes_split():
     assert state[q0] is not state[q1]
 
 
-def test_subcircuit_measurement_causes_split_in_subset():
+def test_subcircuit_measurement_causes_split_in_subset() -> None:
     state = create_container(qs3)
     state.apply_operation(cirq.CNOT(q0, q1))
     state.apply_operation(cirq.CNOT(q0, q2))
@@ -158,7 +158,7 @@ def test_subcircuit_measurement_causes_split_in_subset():
     assert state[q1] is not state[q2]
 
 
-def test_reset_causes_split():
+def test_reset_causes_split() -> None:
     state = create_container(qs2)
     state.apply_operation(cirq.CNOT(q0, q1))
     assert len(set(state.values())) == 2
@@ -168,7 +168,7 @@ def test_reset_causes_split():
     assert state[q0] is not state[None]
 
 
-def test_measurement_does_not_split_if_disabled():
+def test_measurement_does_not_split_if_disabled() -> None:
     state = create_container(qs2, False)
     state.apply_operation(cirq.CNOT(q0, q1))
     assert len(set(state.values())) == 1
@@ -178,7 +178,7 @@ def test_measurement_does_not_split_if_disabled():
     assert state[None] is state[q0]
 
 
-def test_reset_does_not_split_if_disabled():
+def test_reset_does_not_split_if_disabled() -> None:
     state = create_container(qs2, False)
     state.apply_operation(cirq.CNOT(q0, q1))
     assert len(set(state.values())) == 1
@@ -188,7 +188,7 @@ def test_reset_does_not_split_if_disabled():
     assert state[None] is state[q0]
 
 
-def test_measurement_of_all_qubits_causes_split():
+def test_measurement_of_all_qubits_causes_split() -> None:
     state = create_container(qs2)
     state.apply_operation(cirq.CNOT(q0, q1))
     assert len(set(state.values())) == 2
@@ -198,7 +198,7 @@ def test_measurement_of_all_qubits_causes_split():
     assert state[q0] is not state[None]
 
 
-def test_measurement_in_single_qubit_circuit_passes():
+def test_measurement_in_single_qubit_circuit_passes() -> None:
     state = create_container([q0])
     assert len(set(state.values())) == 2
     state.apply_operation(cirq.measure(q0))
@@ -206,25 +206,25 @@ def test_measurement_in_single_qubit_circuit_passes():
     assert state[q0] is not state[None]
 
 
-def test_reorder_succeeds():
+def test_reorder_succeeds() -> None:
     state = create_container(qs2, False)
     reordered = state[q0].transpose_to_qubit_order([q1, q0])
     assert reordered.qubits == (q1, q0)
 
 
-def test_copy_succeeds():
+def test_copy_succeeds() -> None:
     state = create_container(qs2, False)
     copied = state[q0].copy()
     assert copied.qubits == (q0, q1)
 
 
-def test_merge_succeeds():
+def test_merge_succeeds() -> None:
     state = create_container(qs2, False)
     merged = state.create_merged_state()
     assert merged.qubits == (q0, q1)
 
 
-def test_swap_does_not_merge():
+def test_swap_does_not_merge() -> None:
     state = create_container(qs2)
     old_q0 = state[q0]
     old_q1 = state[q1]
@@ -238,14 +238,14 @@ def test_swap_does_not_merge():
     assert state[q1].qubits == (q1,)
 
 
-def test_half_swap_does_merge():
+def test_half_swap_does_merge() -> None:
     state = create_container(qs2)
     state.apply_operation(cirq.SWAP(q0, q1) ** 0.5)
     assert len(set(state.values())) == 2
     assert state[q0] is state[q1]
 
 
-def test_swap_after_entangle_reorders():
+def test_swap_after_entangle_reorders() -> None:
     state = create_container(qs2)
     state.apply_operation(cirq.CX(q0, q1))
     assert len(set(state.values())) == 2
@@ -256,7 +256,7 @@ def test_swap_after_entangle_reorders():
     assert state[q0].qubits == (q1, q0)
 
 
-def test_act_on_gate_does_not_join():
+def test_act_on_gate_does_not_join() -> None:
     state = create_container(qs2)
     assert len(set(state.values())) == 3
     cirq.act_on(cirq.X, state, [q0])
@@ -265,7 +265,7 @@ def test_act_on_gate_does_not_join():
     assert state[q0] is not state[None]
 
 
-def test_field_getters():
+def test_field_getters() -> None:
     state = create_container(qs2)
     assert state.sim_states.keys() == set(qs2) | {None}
     assert state.split_untangled_states

cirq/sim/simulation_state_test.py

@@ -72,20 +72,20 @@ class Composite(cirq.Gate):
         yield cirq.X(*qubits)
 
 
-def test_measurements():
+def test_measurements() -> None:
     args = ExampleSimulationState()
     args.measure([cirq.LineQubit(0)], "test", [False], {})
     assert args.log_of_measurement_results["test"] == [5]
 
 
-def test_decompose():
+def test_decompose() -> None:
     args = ExampleSimulationState()
     assert simulation_state.strat_act_on_from_apply_decompose(
         Composite(), args, [cirq.LineQubit(0)]
     )
 
 
-def test_decompose_for_gate_allocating_qubits_raises():
+def test_decompose_for_gate_allocating_qubits_raises() -> None:
     class Composite(cirq.testing.SingleQubitGate):
         def _decompose_(self, qubits):
             anc = cirq.NamedQubit("anc")
@@ -97,7 +97,7 @@ def test_decompose_for_gate_allocating_qubits_raises():
         simulation_state.strat_act_on_from_apply_decompose(Composite(), args, [cirq.LineQubit(0)])
 
 
-def test_mapping():
+def test_mapping() -> None:
     args = ExampleSimulationState()
     assert list(iter(args)) == cirq.LineQubit.range(2)
     r1 = args[cirq.LineQubit(0)]
@@ -106,7 +106,7 @@ def test_mapping():
         _ = args[cirq.LineQubit(2)]
 
 
-def test_swap_bad_dimensions():
+def test_swap_bad_dimensions() -> None:
     q0 = cirq.LineQubit(0)
     q1 = cirq.LineQid(1, 3)
     args = ExampleSimulationState()
@@ -114,7 +114,7 @@ def test_swap_bad_dimensions():
         args.swap(q0, q1)
 
 
-def test_rename_bad_dimensions():
+def test_rename_bad_dimensions() -> None:
     q0 = cirq.LineQubit(0)
     q1 = cirq.LineQid(1, 3)
     args = ExampleSimulationState()
@@ -122,7 +122,7 @@ def test_rename_bad_dimensions():
         args.rename(q0, q1)
 
 
-def test_transpose_qubits():
+def test_transpose_qubits() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     args = ExampleSimulationState()
     assert args.transpose_to_qubit_order((q1, q0)).qubits == (q1, q0)
@@ -132,14 +132,14 @@ def test_transpose_qubits():
         args.transpose_to_qubit_order((q0, q1, q1))
 
 
-def test_field_getters():
+def test_field_getters() -> None:
     args = ExampleSimulationState()
     assert args.prng is np.random
     assert args.qubit_map == {q: i for i, q in enumerate(cirq.LineQubit.range(2))}
 
 
 @pytest.mark.parametrize('exp', np.linspace(0, 2 * np.pi, 10))
-def test_delegating_gate_unitary(exp):
+def test_delegating_gate_unitary(exp) -> None:
     q = cirq.LineQubit(0)
 
     test_circuit = cirq.Circuit()
@@ -154,7 +154,7 @@ def test_delegating_gate_unitary(exp):
 
 
 @pytest.mark.parametrize('exp', np.linspace(0, 2 * np.pi, 10))
-def test_delegating_gate_channel(exp):
+def test_delegating_gate_channel(exp) -> None:
     q = cirq.LineQubit(0)
 
     test_circuit = cirq.Circuit()
@@ -169,7 +169,7 @@ def test_delegating_gate_channel(exp):
 
 
 @pytest.mark.parametrize('num_ancilla', [1, 2, 3])
-def test_phase_using_dirty_ancilla(num_ancilla: int):
+def test_phase_using_dirty_ancilla(num_ancilla: int) -> None:
     q = cirq.LineQubit(0)
     anc = cirq.NamedQubit.range(num_ancilla, prefix='anc')
 
@@ -184,7 +184,7 @@ def test_phase_using_dirty_ancilla(num_ancilla: int):
 
 @pytest.mark.parametrize('num_ancilla', [1, 2, 3])
 @pytest.mark.parametrize('theta', np.linspace(0, 2 * np.pi, 10))
-def test_phase_using_clean_ancilla(num_ancilla: int, theta: float):
+def test_phase_using_clean_ancilla(num_ancilla: int, theta: float) -> None:
     q = cirq.LineQubit(0)
     u = cirq.MatrixGate(cirq.testing.random_unitary(2))
     test_circuit = cirq.Circuit(

cirq/sim/simulation_utils_test.py

@@ -19,7 +19,7 @@ from cirq.sim import simulation_utils
 
 
 @pytest.mark.parametrize('n,m', [(n, m) for n in range(1, 4) for m in range(1, n + 1)])
-def test_state_probabilities_by_indices(n: int, m: int):
+def test_state_probabilities_by_indices(n: int, m: int) -> None:
     np.random.seed(0)
     state = testing.random_superposition(1 << n)
     d = (state.conj() * state).real