cirq-core 1.6.0.dev20250529194600__py3-none-any.whl → 1.6.0.dev20250530203656__py3-none-any.whl

cirq/contrib/qasm_import/qasm_test.py

@@ -22,7 +22,7 @@ from cirq.contrib.qasm_import import circuit_from_qasm
 from cirq.testing import consistent_qasm as cq
 
 
-def test_consistency_with_qasm_output_and_qiskit():
+def test_consistency_with_qasm_output_and_qiskit() -> None:
     qubits = [cirq.NamedQubit(f'q_{i}') for i in range(4)]
     a, b, c, d = qubits
     circuit1 = cirq.Circuit(
@@ -35,9 +35,9 @@ def test_consistency_with_qasm_output_and_qiskit():
         cirq.H.on(d),
         cirq.S.on(a),
         cirq.T.on(b),
-        cirq.S.on(c) ** -1,
-        cirq.T.on(d) ** -1,
-        cirq.X.on(d) ** 0.125,
+        (cirq.S**-1).on(c),
+        (cirq.T**-1).on(d),
+        (cirq.X**0.125).on(d),
         cirq.TOFFOLI.on(a, b, c),
         cirq.CSWAP.on(d, a, b),
         cirq.SWAP.on(c, d),

cirq/contrib/quirk/export_to_quirk_test.py

@@ -21,7 +21,7 @@ import cirq
 from cirq.contrib.quirk.export_to_quirk import circuit_to_quirk_url
 
 
-def assert_links_to(circuit: cirq.Circuit, expected: str, **kwargs):
+def assert_links_to(circuit: cirq.Circuit, expected: str, **kwargs) -> None:
     actual = circuit_to_quirk_url(circuit, **kwargs)
     actual = actual.replace('\n', '').replace(' ', '').strip()
     expected = expected.replace('],[', '],\n[').strip()
@@ -29,7 +29,7 @@ def assert_links_to(circuit: cirq.Circuit, expected: str, **kwargs):
     assert actual == expected
 
 
-def test_x_z_same_col():
+def test_x_z_same_col() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     circuit = cirq.Circuit(cirq.X(a), cirq.Z(b))
@@ -46,7 +46,7 @@ def test_x_z_same_col():
     )
 
 
-def test_x_cnot_split_cols():
+def test_x_cnot_split_cols() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -60,7 +60,7 @@ def test_x_cnot_split_cols():
     )
 
 
-def test_cz_cnot_split_cols():
+def test_cz_cnot_split_cols() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -74,7 +74,7 @@ def test_cz_cnot_split_cols():
     )
 
 
-def test_various_known_gate_types():
+def test_various_known_gate_types() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     circuit = cirq.Circuit(
@@ -118,7 +118,7 @@ def test_various_known_gate_types():
     )
 
 
-def test_parameterized_gates():
+def test_parameterized_gates() -> None:
     a = cirq.LineQubit(0)
     s = sympy.Symbol('s')
     t = sympy.Symbol('t')
@@ -184,7 +184,7 @@ class MysteryGate(cirq.testing.SingleQubitGate):
         return True
 
 
-def test_various_unknown_gate_types():
+def test_various_unknown_gate_types() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     circuit = cirq.Circuit(
@@ -227,7 +227,7 @@ def test_various_unknown_gate_types():
     )
 
 
-def test_formulaic_exponent_export():
+def test_formulaic_exponent_export() -> None:
     a = cirq.LineQubit(0)
     t = sympy.Symbol('t')
     assert_links_to(
@@ -243,7 +243,7 @@ def test_formulaic_exponent_export():
     )
 
 
-def test_formulaic_rotation_xyz_export():
+def test_formulaic_rotation_xyz_export() -> None:
     a = cirq.LineQubit(0)
     t = sympy.Symbol('t')
     assert_links_to(
@@ -264,9 +264,9 @@ def test_formulaic_rotation_xyz_export():
         _ = circuit_to_quirk_url(cirq.Circuit(cirq.rx(sympy.FallingFactorial(t, t)).on(a)))
 
 
-def test_unrecognized_single_qubit_gate_with_matrix():
+def test_unrecognized_single_qubit_gate_with_matrix() -> None:
     a = cirq.NamedQubit('a')
-    circuit = cirq.Circuit(cirq.PhasedXPowGate(phase_exponent=0).on(a) ** 0.2731)
+    circuit = cirq.Circuit(cirq.PhasedXPowGate(exponent=0.2731, phase_exponent=0).on(a))
     assert_links_to(
         circuit,
         """
@@ -281,7 +281,7 @@ def test_unrecognized_single_qubit_gate_with_matrix():
     )
 
 
-def test_unknown_gate():
+def test_unknown_gate() -> None:
     class UnknownGate(cirq.testing.SingleQubitGate):
         pass
 
@@ -301,7 +301,7 @@ def test_unknown_gate():
     )
 
 
-def test_controlled_gate():
+def test_controlled_gate() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     circuit = cirq.Circuit(cirq.ControlledGate(cirq.ControlledGate(cirq.CZ)).on(a, d, c, b))
     assert_links_to(
@@ -336,7 +336,7 @@ def test_controlled_gate():
     )
 
 
-def test_toffoli():
+def test_toffoli() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
 
     # Raw.
@@ -374,7 +374,7 @@ def test_toffoli():
     )
 
 
-def test_fredkin():
+def test_fredkin() -> None:
     a, b, c = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(cirq.FREDKIN(a, b, c))
     assert_links_to(
@@ -400,7 +400,7 @@ def test_fredkin():
     )
 
 
-def test_ccz():
+def test_ccz() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
 
     # Raw.

cirq/devices/insertion_noise_model.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Any, Sequence, TYPE_CHECKING
+from typing import Any, Mapping, Sequence, TYPE_CHECKING
 
 from cirq import devices
 from cirq.devices import noise_utils
@@ -44,7 +44,7 @@ class InsertionNoiseModel(devices.NoiseModel):
             with PHYSICAL_GATE_TAG.
     """
 
-    ops_added: dict[noise_utils.OpIdentifier, cirq.Operation] = dataclasses.field(
+    ops_added: Mapping[noise_utils.OpIdentifier, cirq.Operation] = dataclasses.field(
         default_factory=dict
     )
     prepend: bool = False

cirq/linalg/transformations_test.py

@@ -21,8 +21,10 @@ import cirq
 import cirq.testing
 from cirq import linalg
 
+_DEFAULT_ARRAY = np.asarray([1])
 
-def test_reflection_matrix_pow_consistent_results():
+
+def test_reflection_matrix_pow_consistent_results() -> None:
     x = np.array([[0, 1], [1, 0]])
     sqrt_x = cirq.reflection_matrix_pow(x, 0.5)
     np.testing.assert_allclose(np.dot(sqrt_x, sqrt_x), x, atol=1e-10)
@@ -42,7 +44,7 @@ def test_reflection_matrix_pow_consistent_results():
     np.testing.assert_allclose(np.dot(sqrt_yh, sqrt_yh), yh, atol=1e-10)
 
 
-def test_reflection_matrix_sign_preference_under_perturbation():
+def test_reflection_matrix_sign_preference_under_perturbation() -> None:
     x = np.array([[0, 1], [1, 0]])
     sqrt_x = np.array([[1, -1j], [-1j, 1]]) * (1 + 1j) / 2
     np.testing.assert_allclose(cirq.reflection_matrix_pow(x, 0.5), sqrt_x, atol=1e-8)
@@ -57,7 +59,7 @@ def test_reflection_matrix_sign_preference_under_perturbation():
         np.testing.assert_allclose(sqrt_px, expected_sqrt_px, atol=1e-10)
 
 
-def test_match_global_phase():
+def test_match_global_phase() -> None:
     a = np.array([[5, 4], [3, -2]])
     b = np.array([[0.000001, 0], [0, 1j]])
     c, d = cirq.match_global_phase(a, b)
@@ -65,7 +67,7 @@ def test_match_global_phase():
     np.testing.assert_allclose(d, b * -1j, atol=1e-10)
 
 
-def test_match_global_phase_incompatible_shape():
+def test_match_global_phase_incompatible_shape() -> None:
     a = np.array([1])
     b = np.array([1, 2])
     c, d = cirq.match_global_phase(a, b)
@@ -87,7 +89,7 @@ def test_match_global_phase_incompatible_shape():
     assert np.allclose(d, b)
 
 
-def test_match_global_phase_zeros():
+def test_match_global_phase_zeros() -> None:
     z = np.array([[0, 0], [0, 0]])
     b = np.array([[1, 1], [1, 1]])
 
@@ -104,7 +106,7 @@ def test_match_global_phase_zeros():
     np.testing.assert_allclose(z, z4, atol=1e-10)
 
 
-def test_match_global_no_float_error_when_axis_aligned():
+def test_match_global_no_float_error_when_axis_aligned() -> None:
     a = np.array([[1, 1.1], [-1.3, np.pi]])
     a2, _ = cirq.match_global_phase(a, a)
     a3, _ = cirq.match_global_phase(a * 1j, a * 1j)
@@ -117,7 +119,7 @@ def test_match_global_no_float_error_when_axis_aligned():
     assert np.all(a5 == a)
 
 
-def test_targeted_left_multiply_matches_kron_then_dot():
+def test_targeted_left_multiply_matches_kron_then_dot() -> None:
     t = np.array([1, 2, 3, 4, 5, 6, 7, 8])
     m = np.array([[2, 3], [5, 7]])
     i = np.eye(2)
@@ -161,7 +163,7 @@ def test_targeted_left_multiply_matches_kron_then_dot():
         cirq.targeted_left_multiply(left_matrix=m, right_target=common, out=m, target_axes=[2])
 
 
-def test_targeted_left_multiply_reorders_matrices():
+def test_targeted_left_multiply_reorders_matrices() -> None:
     t = np.eye(4).reshape((2, 2, 2, 2))
     m = np.array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0]).reshape((2, 2, 2, 2))
 
@@ -176,7 +178,7 @@ def test_targeted_left_multiply_reorders_matrices():
     )
 
 
-def test_targeted_left_multiply_out():
+def test_targeted_left_multiply_out() -> None:
     left = np.array([[2, 3], [5, 7]])
     right = np.array([1, -1])
     out = np.zeros(2)
@@ -188,7 +190,7 @@ def test_targeted_left_multiply_out():
     np.testing.assert_allclose(result, np.array([-1, -2]), atol=1e-8)
 
 
-def test_targeted_conjugate_simple():
+def test_targeted_conjugate_simple() -> None:
     a = np.array([[0, 1j], [0, 0]])
     # yapf: disable
     b = np.reshape(
@@ -212,7 +214,7 @@ def test_targeted_conjugate_simple():
     np.testing.assert_almost_equal(result, expected)
 
 
-def test_targeted_conjugate():
+def test_targeted_conjugate() -> None:
     a = np.reshape([0, 1, 2j, 3j], (2, 2))
     b = np.reshape(np.arange(16), (2,) * 4)
     result = cirq.targeted_conjugate_about(a, b, [0])
@@ -224,7 +226,7 @@ def test_targeted_conjugate():
     np.testing.assert_almost_equal(result, expected)
 
 
-def test_targeted_conjugate_multiple_indices():
+def test_targeted_conjugate_multiple_indices() -> None:
     a = np.reshape(np.arange(16) + 1j, (2, 2, 2, 2))
     b = np.reshape(np.arange(16), (2,) * 4)
     result = cirq.targeted_conjugate_about(a, b, [0, 1])
@@ -232,7 +234,7 @@ def test_targeted_conjugate_multiple_indices():
     np.testing.assert_almost_equal(result, expected)
 
 
-def test_targeted_conjugate_multiple_indices_flip_order():
+def test_targeted_conjugate_multiple_indices_flip_order() -> None:
     a = np.reshape(np.arange(16) + 1j, (2, 2, 2, 2))
     b = np.reshape(np.arange(16), (2,) * 4)
     result = cirq.targeted_conjugate_about(a, b, [1, 0], [3, 2])
@@ -240,7 +242,7 @@ def test_targeted_conjugate_multiple_indices_flip_order():
     np.testing.assert_almost_equal(result, expected)
 
 
-def test_targeted_conjugate_out():
+def test_targeted_conjugate_out() -> None:
     a = np.reshape([0, 1, 2j, 3j], (2, 2))
     b = np.reshape(np.arange(16), (2,) * 4)
     buffer = np.empty((2,) * 4, dtype=a.dtype)
@@ -251,7 +253,7 @@ def test_targeted_conjugate_out():
     np.testing.assert_almost_equal(result, expected)
 
 
-def test_apply_matrix_to_slices():
+def test_apply_matrix_to_slices() -> None:
     # Output is input.
     with pytest.raises(ValueError, match='out'):
         target = np.eye(2)
@@ -303,7 +305,7 @@ def test_apply_matrix_to_slices():
     np.testing.assert_allclose(actual, np.array([1, 13, 31, 4]))
 
 
-def test_partial_trace():
+def test_partial_trace() -> None:
     a = np.reshape(np.arange(4), (2, 2))
     b = np.reshape(np.arange(9) + 4, (3, 3))
     c = np.reshape(np.arange(16) + 13, (4, 4))
@@ -337,21 +339,21 @@ def test_partial_trace():
     )
 
 
-def test_partial_trace_non_kron():
+def test_partial_trace_non_kron() -> None:
     tensor = np.zeros((2, 2, 2, 2))
     tensor[0, 0, 0, 0] = 1
     tensor[1, 1, 1, 1] = 4
     np.testing.assert_almost_equal(cirq.partial_trace(tensor, [0]), np.array([[1, 0], [0, 4]]))
 
 
-def test_partial_trace_invalid_inputs():
+def test_partial_trace_invalid_inputs() -> None:
     with pytest.raises(ValueError, match='2, 3, 2, 2'):
         cirq.partial_trace(np.reshape(np.arange(2 * 3 * 2 * 2), (2, 3, 2, 2)), [1])
     with pytest.raises(ValueError, match='2'):
         cirq.partial_trace(np.reshape(np.arange(2 * 2 * 2 * 2), (2,) * 4), [2])
 
 
-def test_sub_state_vector():
+def test_sub_state_vector() -> None:
     a = np.arange(4) / np.linalg.norm(np.arange(4))
     b = (np.arange(8) + 3) / np.linalg.norm(np.arange(8) + 3)
     c = (np.arange(16) + 1) / np.linalg.norm(np.arange(16) + 1)
@@ -384,40 +386,66 @@ def test_sub_state_vector():
     )
 
     # Reject factoring for very tight tolerance.
-    assert cirq.sub_state_vector(state, [0, 1], default=None, atol=1e-16) is None
-    assert cirq.sub_state_vector(state, [2, 3, 4], default=None, atol=1e-16) is None
-    assert cirq.sub_state_vector(state, [5, 6, 7, 8], default=None, atol=1e-16) is None
+    assert (
+        cirq.sub_state_vector(state, [0, 1], default=_DEFAULT_ARRAY, atol=1e-16) is _DEFAULT_ARRAY
+    )
+    assert (
+        cirq.sub_state_vector(state, [2, 3, 4], default=_DEFAULT_ARRAY, atol=1e-16)
+        is _DEFAULT_ARRAY
+    )
+    assert (
+        cirq.sub_state_vector(state, [5, 6, 7, 8], default=_DEFAULT_ARRAY, atol=1e-16)
+        is _DEFAULT_ARRAY
+    )
 
     # Permit invalid factoring for loose tolerance.
     for q1 in range(9):
-        assert cirq.sub_state_vector(state, [q1], default=None, atol=1) is not None
+        assert (
+            cirq.sub_state_vector(state, [q1], default=_DEFAULT_ARRAY, atol=1) is not _DEFAULT_ARRAY
+        )
 
 
-def test_sub_state_vector_bad_subset():
+def test_sub_state_vector_bad_subset() -> None:
     a = cirq.testing.random_superposition(4)
     b = cirq.testing.random_superposition(8)
     state = np.kron(a, b).reshape((2, 2, 2, 2, 2))
 
     for q1 in range(5):
-        assert cirq.sub_state_vector(state, [q1], default=None, atol=1e-8) is None
+        assert (
+            cirq.sub_state_vector(state, [q1], default=_DEFAULT_ARRAY, atol=1e-8) is _DEFAULT_ARRAY
+        )
     for q1 in range(2):
         for q2 in range(2, 5):
-            assert cirq.sub_state_vector(state, [q1, q2], default=None, atol=1e-8) is None
+            assert (
+                cirq.sub_state_vector(state, [q1, q2], default=_DEFAULT_ARRAY, atol=1e-8)
+                is _DEFAULT_ARRAY
+            )
     for q3 in range(2, 5):
-        assert cirq.sub_state_vector(state, [0, 1, q3], default=None, atol=1e-8) is None
+        assert (
+            cirq.sub_state_vector(state, [0, 1, q3], default=_DEFAULT_ARRAY, atol=1e-8)
+            is _DEFAULT_ARRAY
+        )
     for q4 in range(2):
-        assert cirq.sub_state_vector(state, [2, 3, 4, q4], default=None, atol=1e-8) is None
+        assert (
+            cirq.sub_state_vector(state, [2, 3, 4, q4], default=_DEFAULT_ARRAY, atol=1e-8)
+            is _DEFAULT_ARRAY
+        )
 
 
-def test_sub_state_vector_non_kron():
+def test_sub_state_vector_non_kron() -> None:
     a = np.array([1, 0, 0, 0, 0, 0, 0, 1]) / np.sqrt(2)
     b = np.array([1, 1]) / np.sqrt(2)
     state = np.kron(a, b).reshape((2, 2, 2, 2))
 
     for q1 in [0, 1, 2]:
-        assert cirq.sub_state_vector(state, [q1], default=None, atol=1e-8) is None
+        assert (
+            cirq.sub_state_vector(state, [q1], default=_DEFAULT_ARRAY, atol=1e-8) is _DEFAULT_ARRAY
+        )
     for q1 in [0, 1, 2]:
-        assert cirq.sub_state_vector(state, [q1, 3], default=None, atol=1e-8) is None
+        assert (
+            cirq.sub_state_vector(state, [q1, 3], default=_DEFAULT_ARRAY, atol=1e-8)
+            is _DEFAULT_ARRAY
+        )
 
     with pytest.raises(ValueError, match='factored'):
         _ = cirq.sub_state_vector(a, [0], atol=1e-8)
@@ -425,7 +453,7 @@ def test_sub_state_vector_non_kron():
     assert cirq.equal_up_to_global_phase(cirq.sub_state_vector(state, [3]), b, atol=1e-8)
 
 
-def test_sub_state_vector_invalid_inputs():
+def test_sub_state_vector_invalid_inputs() -> None:
 
     # State cannot be expressed as a separable pure state.
     with pytest.raises(ValueError, match='7'):
@@ -452,7 +480,7 @@ def test_sub_state_vector_invalid_inputs():
         cirq.sub_state_vector(state, [0, 1, 2], atol=1e-8)
 
 
-def test_partial_trace_of_state_vector_as_mixture_invalid_input():
+def test_partial_trace_of_state_vector_as_mixture_invalid_input() -> None:
 
     with pytest.raises(ValueError, match='7'):
         cirq.partial_trace_of_state_vector_as_mixture(np.arange(7), [1, 2], atol=1e-8)
@@ -471,7 +499,7 @@ def test_partial_trace_of_state_vector_as_mixture_invalid_input():
         cirq.partial_trace_of_state_vector_as_mixture(state, [0, 1, 2], atol=1e-8)
 
 
-def mixtures_equal(m1, m2, atol=1e-7):
+def mixtures_equal(m1, m2, atol=1e-7) -> bool:
     for (p1, v1), (p2, v2) in zip(m1, m2):
         if not (
             cirq.approx_eq(p1, p2, atol=atol) and cirq.equal_up_to_global_phase(v1, v2, atol=atol)
@@ -480,7 +508,7 @@ def mixtures_equal(m1, m2, atol=1e-7):
     return True
 
 
-def test_partial_trace_of_state_vector_as_mixture_pure_result():
+def test_partial_trace_of_state_vector_as_mixture_pure_result() -> None:
     a = cirq.testing.random_superposition(4)
     b = cirq.testing.random_superposition(8)
     c = cirq.testing.random_superposition(16)
@@ -534,7 +562,7 @@ def test_partial_trace_of_state_vector_as_mixture_pure_result():
     )
 
 
-def test_partial_trace_of_state_vector_as_mixture_pure_result_qudits():
+def test_partial_trace_of_state_vector_as_mixture_pure_result_qudits() -> None:
     a = cirq.testing.random_superposition(2)
     b = cirq.testing.random_superposition(3)
     c = cirq.testing.random_superposition(4)
@@ -563,7 +591,7 @@ def test_partial_trace_of_state_vector_as_mixture_pure_result_qudits():
     )
 
 
-def test_partial_trace_of_state_vector_as_mixture_mixed_result():
+def test_partial_trace_of_state_vector_as_mixture_mixed_result() -> None:
     state = np.array([1, 0, 0, 1]) / np.sqrt(2)
     truth = ((0.5, np.array([1, 0])), (0.5, np.array([0, 1])))
     for q1 in [0, 1]:
@@ -591,7 +619,7 @@ def test_partial_trace_of_state_vector_as_mixture_mixed_result():
         assert mixtures_equal(mixture, truth)
 
 
-def test_partial_trace_of_state_vector_as_mixture_mixed_result_qudits():
+def test_partial_trace_of_state_vector_as_mixture_mixed_result_qudits() -> None:
     state = np.array([[1, 0, 0], [0, 0, 0], [0, 0, 1]]) / np.sqrt(2)
     truth = ((0.5, np.array([1, 0, 0])), (0.5, np.array([0, 0, 1])))
     for q1 in [0, 1]:
@@ -599,14 +627,14 @@ def test_partial_trace_of_state_vector_as_mixture_mixed_result_qudits():
         assert mixtures_equal(mixture, truth)
 
 
-def test_to_special():
+def test_to_special() -> None:
     u = cirq.testing.random_unitary(4)
     su = cirq.to_special(u)
     assert not cirq.is_special_unitary(u)
     assert cirq.is_special_unitary(su)
 
 
-def test_default_tolerance():
+def test_default_tolerance() -> None:
     a, b = cirq.LineQubit.range(2)
     final_state_vector = (
         cirq.Simulator()
@@ -620,7 +648,7 @@ def test_default_tolerance():
 
 @pytest.mark.parametrize('state_1', [0, 1])
 @pytest.mark.parametrize('state_2', [0, 1])
-def test_factor_state_vector(state_1: int, state_2: int):
+def test_factor_state_vector(state_1: int, state_2: int) -> None:
     # Kron two state vectors and apply a phase. Factoring should produce the expected results.
     n = 12
     for i in range(n):
@@ -638,7 +666,7 @@ def test_factor_state_vector(state_1: int, state_2: int):
 
 
 @pytest.mark.parametrize('num_dimensions', [*range(1, 7)])
-def test_transpose_flattened_array(num_dimensions):
+def test_transpose_flattened_array(num_dimensions) -> None:
     np.random.seed(0)
     for _ in range(10):
         shape = np.random.randint(1, 5, (num_dimensions,)).tolist()
@@ -658,7 +686,7 @@ def test_can_numpy_support_shape(shape: tuple[int, ...], result: bool) -> None:
 
 
 @pytest.mark.parametrize('coeff', [1, 1j, -1, -1j, 1j**0.5, 1j**0.3])
-def test_phase_delta(coeff):
+def test_phase_delta(coeff) -> None:
     u1 = cirq.testing.random_unitary(4)
     u2 = u1 * coeff
     np.testing.assert_almost_equal(linalg.phase_delta(u1, u2), coeff)

cirq/ops/boolean_hamiltonian_test.py

@@ -56,7 +56,7 @@ import cirq.ops.boolean_hamiltonian as bh
         '(x2 | x1) ^ x0',
     ],
 )
-def test_circuit(boolean_str):
+def test_circuit(boolean_str) -> None:
     boolean_expr = sympy_parser.parse_expr(boolean_str)
     var_names = cirq.parameter_names(boolean_expr)
     qubits = [cirq.NamedQubit(name) for name in var_names]
@@ -76,7 +76,7 @@ def test_circuit(boolean_str):
     circuit.append(cirq.H.on_each(*qubits))
 
     hamiltonian_gate = cirq.BooleanHamiltonianGate(
-        {q.name: q for q in qubits}, [boolean_str], 0.1 * math.pi
+        [q.name for q in qubits], [boolean_str], 0.1 * math.pi
     )
 
     assert hamiltonian_gate.num_qubits() == n
@@ -90,7 +90,7 @@ def test_circuit(boolean_str):
     np.testing.assert_array_equal(actual, expected)
 
 
-def test_gate_with_custom_names():
+def test_gate_with_custom_names() -> None:
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     gate = cirq.BooleanHamiltonianGate(['a', 'b'], ['a'], 0.1)
     assert cirq.decompose(gate.on(q0, q1)) == [cirq.Rz(rads=-0.05).on(q0)]
@@ -104,7 +104,7 @@ def test_gate_with_custom_names():
         gate.on(q0, cirq.LineQid(1, 3))
 
 
-def test_gate_consistent():
+def test_gate_consistent() -> None:
     gate = cirq.BooleanHamiltonianGate(['a', 'b'], ['a'], 0.1)
     op = gate.on(*cirq.LineQubit.range(2))
     cirq.testing.assert_implements_consistent_protocols(gate)
@@ -119,7 +119,7 @@ def test_gate_consistent():
         (3, [(), (0,), (0, 1), (1,), (1, 2), (0, 1, 2), (0, 2), (2,)]),
     ],
 )
-def test_gray_code_sorting(n_bits, expected_hs):
+def test_gray_code_sorting(n_bits, expected_hs) -> None:
     hs_template = []
     for x in range(2**n_bits):
         h = []
@@ -142,7 +142,7 @@ def test_gray_code_sorting(n_bits, expected_hs):
 @pytest.mark.parametrize(
     'seq_a,seq_b,expected', [((), (), 0), ((), (0,), -1), ((0,), (), 1), ((0,), (0,), 0)]
 )
-def test_gray_code_comparison(seq_a, seq_b, expected):
+def test_gray_code_comparison(seq_a, seq_b, expected) -> None:
     assert bh._gray_code_comparator(seq_a, seq_b) == expected
 
 
@@ -173,7 +173,7 @@ def test_gray_code_comparison(seq_a, seq_b, expected):
 )
 def test_simplify_commuting_cnots(
     input_cnots, input_flip_control_and_target, expected_simplified, expected_output_cnots
-):
+) -> None:
     actual_simplified, actual_output_cnots = bh._simplify_commuting_cnots(
         input_cnots, input_flip_control_and_target
     )
@@ -206,7 +206,7 @@ def test_simplify_commuting_cnots(
 )
 def test_simplify_cnots_triplets(
     input_cnots, input_flip_control_and_target, expected_simplified, expected_output_cnots
-):
+) -> None:
     actual_simplified, actual_output_cnots = bh._simplify_cnots_triplets(
         input_cnots, input_flip_control_and_target
     )