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

cirq/testing/gate_features_test.py

@@ -17,7 +17,7 @@ import pytest
 import cirq
 
 
-def test_two_qubit_gate_is_abstract_can_implement():
+def test_two_qubit_gate_is_abstract_can_implement() -> None:
     class Included(cirq.testing.TwoQubitGate):
         def matrix(self):
             pass
@@ -25,7 +25,7 @@ def test_two_qubit_gate_is_abstract_can_implement():
     assert isinstance(Included(), cirq.testing.TwoQubitGate)
 
 
-def test_two_qubit_gate_validate_pass():
+def test_two_qubit_gate_validate_pass() -> None:
     class Example(cirq.testing.TwoQubitGate):
         def matrix(self):
             pass
@@ -41,7 +41,7 @@ def test_two_qubit_gate_validate_pass():
     g.validate_args([q3, q2])
 
 
-def test_two_qubit_gate_validate_wrong_number():
+def test_two_qubit_gate_validate_wrong_number() -> None:
     class Example(cirq.testing.TwoQubitGate):
         def matrix(self):
             pass
@@ -59,7 +59,7 @@ def test_two_qubit_gate_validate_wrong_number():
         g.validate_args([q1, q2, q3])
 
 
-def test_three_qubit_gate_validate():
+def test_three_qubit_gate_validate() -> None:
     class Example(cirq.testing.ThreeQubitGate):
         def matrix(self):
             pass
@@ -80,6 +80,6 @@ def test_three_qubit_gate_validate():
         g.validate_args([a, b, c, d])
 
 
-def test_does_not_support_serialization_gate():
+def test_does_not_support_serialization_gate() -> None:
     g = cirq.testing.DoesNotSupportSerializationGate(n_qubits=4)
     assert g.num_qubits() == 4

cirq/testing/json_test.py

@@ -17,16 +17,16 @@ import pytest
 from cirq.testing.json import spec_for
 
 
-def test_module_missing_json_test_data():
+def test_module_missing_json_test_data() -> None:
     with pytest.raises(ValueError, match="json_test_data"):
         spec_for('cirq.testing.test_data.test_module_missing_json_test_data')
 
 
-def test_module_missing_testspec():
+def test_module_missing_testspec() -> None:
     with pytest.raises(ValueError, match="TestSpec"):
         spec_for('cirq.testing.test_data.test_module_missing_testspec')
 
 
-def test_missing_module():
+def test_missing_module() -> None:
     with pytest.raises(ModuleNotFoundError):
         spec_for('non_existent')

cirq/testing/lin_alg_utils_test.py

@@ -28,14 +28,14 @@ from cirq.testing import (
 
 
 @pytest.mark.parametrize('dim', range(1, 10))
-def test_random_superposition(dim):
+def test_random_superposition(dim) -> None:
     state = random_superposition(dim)
 
     assert dim == len(state)
     assert np.isclose(np.linalg.norm(state), 1.0)
 
 
-def test_random_superposition_deterministic_given_seed():
+def test_random_superposition_deterministic_given_seed() -> None:
     state1 = random_superposition(10, random_state=1234)
     state2 = random_superposition(10, random_state=1234)
 
@@ -43,7 +43,7 @@ def test_random_superposition_deterministic_given_seed():
 
 
 @pytest.mark.parametrize('dim', range(1, 10))
-def test_random_density_matrix(dim):
+def test_random_density_matrix(dim) -> None:
     state = random_density_matrix(dim)
 
     assert state.shape == (dim, dim)
@@ -53,14 +53,14 @@ def test_random_density_matrix(dim):
     assert np.all(eigs >= 0)
 
 
-def test_random_density_matrix_deterministic_given_seed():
+def test_random_density_matrix_deterministic_given_seed() -> None:
     state1 = random_density_matrix(10, random_state=1234)
     state2 = random_density_matrix(10, random_state=1234)
 
     np.testing.assert_equal(state1, state2)
 
 
-def test_random_unitary():
+def test_random_unitary() -> None:
     u1 = random_unitary(2)
     u2 = random_unitary(2)
     assert is_unitary(u1)
@@ -68,7 +68,7 @@ def test_random_unitary():
     assert not np.allclose(u1, u2)
 
 
-def test_random_orthogonal():
+def test_random_orthogonal() -> None:
     o1 = random_orthogonal(2)
     o2 = random_orthogonal(2)
     assert is_orthogonal(o1)
@@ -76,14 +76,14 @@ def test_random_orthogonal():
     assert not np.allclose(o1, o2)
 
 
-def test_random_orthogonal_deterministic_given_seed():
+def test_random_orthogonal_deterministic_given_seed() -> None:
     o1 = random_orthogonal(2, random_state=1234)
     o2 = random_orthogonal(2, random_state=1234)
 
     np.testing.assert_equal(o1, o2)
 
 
-def test_random_special_unitary():
+def test_random_special_unitary() -> None:
     u1 = random_special_unitary(2)
     u2 = random_special_unitary(2)
     assert is_special_unitary(u1)
@@ -91,7 +91,7 @@ def test_random_special_unitary():
     assert not np.allclose(u1, u2)
 
 
-def test_seeded_special_unitary():
+def test_seeded_special_unitary() -> None:
     u1 = random_special_unitary(2, random_state=np.random.RandomState(1))
     u2 = random_special_unitary(2, random_state=np.random.RandomState(1))
     u3 = random_special_unitary(2, random_state=np.random.RandomState(2))
@@ -99,7 +99,7 @@ def test_seeded_special_unitary():
     assert not np.allclose(u1, u3)
 
 
-def test_random_special_orthogonal():
+def test_random_special_orthogonal() -> None:
     o1 = random_special_orthogonal(2)
     o2 = random_special_orthogonal(2)
     assert is_special_orthogonal(o1)
@@ -107,14 +107,14 @@ def test_random_special_orthogonal():
     assert not np.allclose(o1, o2)
 
 
-def test_random_special_orthogonal_deterministic_given_seed():
+def test_random_special_orthogonal_deterministic_given_seed() -> None:
     o1 = random_special_orthogonal(2, random_state=1234)
     o2 = random_special_orthogonal(2, random_state=1234)
 
     np.testing.assert_equal(o1, o2)
 
 
-def test_assert_allclose_up_to_global_phase():
+def test_assert_allclose_up_to_global_phase() -> None:
     assert_allclose_up_to_global_phase(np.array([[1]]), np.array([[1j]]), atol=0)
 
     with pytest.raises(AssertionError):

cirq/testing/logs_test.py

@@ -20,7 +20,7 @@ import pytest
 import cirq.testing
 
 
-def test_assert_logs_valid_single_logs():
+def test_assert_logs_valid_single_logs() -> None:
     with cirq.testing.assert_logs('apple'):
         logging.error('orange apple fruit')
 
@@ -43,7 +43,7 @@ def test_assert_logs_valid_single_logs():
         warnings.warn('orange apple fruit')
 
 
-def test_assert_logs_invalid_single_logs():
+def test_assert_logs_invalid_single_logs() -> None:
     match = (
         '^dog expected to appear in log messages but it was not found. '
         'Log messages: \\[\'orange apple fruit\'\\].$'
@@ -57,7 +57,7 @@ def test_assert_logs_invalid_single_logs():
             logging.error('orange apple fruit')
 
 
-def test_assert_logs_valid_multiple_logs():
+def test_assert_logs_valid_multiple_logs() -> None:
     with cirq.testing.assert_logs('apple', count=2):
         logging.error('orange apple fruit')
         logging.error('other')
@@ -84,7 +84,7 @@ def test_assert_logs_valid_multiple_logs():
         logging.warning('other two')
 
 
-def test_assert_logs_invalid_multiple_logs():
+def test_assert_logs_invalid_multiple_logs() -> None:
     with pytest.raises(AssertionError, match='^Expected 1 log message but got 2. Log messages.*$'):
         with cirq.testing.assert_logs('dog'):
             logging.error('orange apple fruit')
@@ -107,7 +107,7 @@ def test_assert_logs_invalid_multiple_logs():
             logging.error('whatever')
 
 
-def test_assert_logs_log_level():
+def test_assert_logs_log_level() -> None:
     # Default minlevel is WARNING, max level CRITICAL
     with cirq.testing.assert_logs('apple'):
         logging.error('orange apple fruit')
@@ -131,7 +131,7 @@ def test_assert_logs_log_level():
             logging.warning("info warning 1")
 
 
-def test_invalid_levels():
+def test_invalid_levels() -> None:
     with pytest.raises(ValueError, match="min_level.*max_level"):
         with cirq.testing.assert_logs(
             "test", min_level=logging.CRITICAL, max_level=logging.WARNING
@@ -139,7 +139,7 @@ def test_invalid_levels():
             pass
 
 
-def test_assert_logs_warnings():
+def test_assert_logs_warnings() -> None:
     # Capture all warnings in one context, so that test cases that will
     # display a warning do not do so when the test is run.
     with warnings.catch_warnings(record=True):

cirq/testing/no_identifier_qubit_test.py

@@ -15,16 +15,16 @@
 import cirq
 
 
-def test_named_qubit_repr():
+def test_named_qubit_repr() -> None:
     q = cirq.testing.NoIdentifierQubit()
     assert repr(q) == "cirq.testing.NoIdentifierQubit()"
 
 
-def test_comparsion_key():
+def test_comparsion_key() -> None:
     q = cirq.testing.NoIdentifierQubit()
     p = cirq.testing.NoIdentifierQubit()
     assert p == q
 
 
-def test_to_json():
+def test_to_json() -> None:
     assert cirq.testing.NoIdentifierQubit()._json_dict_() == {}

cirq/testing/op_tree_test.py

@@ -17,7 +17,7 @@ import cirq
 from cirq.testing import assert_equivalent_op_tree
 
 
-def test_assert_equivalent_op_tree():
+def test_assert_equivalent_op_tree() -> None:
     assert_equivalent_op_tree([], [])
     a = cirq.NamedQubit("a")
     assert_equivalent_op_tree([cirq.X(a)], [cirq.X(a)])

cirq/testing/order_tester_test.py

@@ -62,7 +62,7 @@ class MockValue:
         return f'MockValue(val={self.val!r}, ...)'
 
 
-def test_add_ordering_group_correct():
+def test_add_ordering_group_correct() -> None:
     ot = cirq.testing.OrderTester()
     ot.add_ascending(-4, 0)
     ot.add_ascending(1, 2)
@@ -70,7 +70,7 @@ def test_add_ordering_group_correct():
     ot.add_ascending_equivalence_group(float('inf'), float('inf'))
 
 
-def test_add_ordering_group_incorrect():
+def test_add_ordering_group_incorrect() -> None:
     ot = cirq.testing.OrderTester()
     ot.add_ascending(0)
     with pytest.raises(AssertionError):
@@ -88,7 +88,7 @@ def test_add_ordering_group_incorrect():
         ot.add_ascending(0)
 
 
-def test_propagates_internal_errors():
+def test_propagates_internal_errors() -> None:
     class UnorderableClass:  # pragma: no cover
         def __eq__(self, other):
             return NotImplemented
@@ -113,7 +113,7 @@ def test_propagates_internal_errors():
         ot.add_ascending(UnorderableClass())
 
 
-def test_add_ascending_equivalence_group():
+def test_add_ascending_equivalence_group() -> None:
     ot = cirq.testing.OrderTester()
     with pytest.raises(AssertionError, match='Expected X=1 to equal Y=3'):
         ot.add_ascending_equivalence_group(1, 3)
@@ -127,7 +127,7 @@ def test_add_ascending_equivalence_group():
     ot.add_ascending_equivalence_group(5)
 
 
-def test_fails_to_return_not_implemented_vs_unknown():
+def test_fails_to_return_not_implemented_vs_unknown() -> None:
     def make_impls(bad_index: int, bad_result: bool):
         def make_impl(i, op):
             def impl(x, y):
@@ -153,7 +153,7 @@ def test_fails_to_return_not_implemented_vs_unknown():
     ot.add_ascending(MockValue(1, *good_impls))
 
 
-def test_fails_on_inconsistent_hashes():
+def test_fails_on_inconsistent_hashes() -> None:
     class ModifiedHash(tuple):
         def __hash__(self):
             return super().__hash__() ^ 1

cirq/testing/pytest_utils_test.py

@@ -19,7 +19,7 @@ import pytest
 import cirq
 
 
-def test_retry_once_after_timeout():
+def test_retry_once_after_timeout() -> None:
     testfunc = Mock(side_effect=[TimeoutError("first call fails"), None])
     decoratedfunc = cirq.testing.retry_once_after_timeout(testfunc)
     with pytest.warns(UserWarning, match="Retrying.*transitive TimeoutError"):
@@ -27,7 +27,7 @@ def test_retry_once_after_timeout():
     assert testfunc.call_count == 2
 
 
-def test_retry_once_with_later_random_values():
+def test_retry_once_with_later_random_values() -> None:
     testfunc = Mock(side_effect=[AssertionError("first call fails"), None])
     decoratedfunc = cirq.testing.retry_once_with_later_random_values(testfunc)
     with pytest.warns(UserWarning, match="Retrying.*failing seed.*pytest-randomly"):

cirq/testing/random_circuit_test.py

@@ -21,7 +21,7 @@ import cirq
 import cirq.testing
 
 
-def test_random_circuit_errors():
+def test_random_circuit_errors() -> None:
     with pytest.raises(ValueError, match='but was -1'):
         _ = cirq.testing.random_circuit(qubits=5, n_moments=5, op_density=-1)
 
@@ -92,7 +92,7 @@ def test_random_circuit(
 
 
 @pytest.mark.parametrize('seed', [random.randint(0, 2**32) for _ in range(10)])
-def test_random_circuit_reproducible_with_seed(seed):
+def test_random_circuit_reproducible_with_seed(seed) -> None:
     wrappers = (lambda s: s, np.random.RandomState)
     circuits = [
         cirq.testing.random_circuit(
@@ -105,7 +105,7 @@ def test_random_circuit_reproducible_with_seed(seed):
     eq.add_equality_group(*circuits)
 
 
-def test_random_circuit_not_expected_number_of_qubits():
+def test_random_circuit_not_expected_number_of_qubits() -> None:
     circuit = cirq.testing.random_circuit(
         qubits=3, n_moments=1, op_density=1.0, gate_domain={cirq.CNOT: 2}
     )
@@ -114,7 +114,7 @@ def test_random_circuit_not_expected_number_of_qubits():
     assert len(circuit.all_qubits()) == 2
 
 
-def test_random_circuit_reproducible_between_runs():
+def test_random_circuit_reproducible_between_runs() -> None:
     circuit = cirq.testing.random_circuit(5, 8, 0.5, random_state=77)
     expected_diagram = """
                   ┌──┐
@@ -132,7 +132,7 @@ def test_random_circuit_reproducible_between_runs():
     cirq.testing.assert_has_diagram(circuit, expected_diagram)
 
 
-def test_random_two_qubit_circuit_with_czs():
+def test_random_two_qubit_circuit_with_czs() -> None:
     num_czs = lambda circuit: len(
         [o for o in circuit.all_operations() if isinstance(o.gate, cirq.CZPowGate)]
     )

cirq/testing/repr_pretty_tester_test.py

@@ -15,7 +15,7 @@
 import cirq.testing
 
 
-def test_fake_printer():
+def test_fake_printer() -> None:
     p = cirq.testing.FakePrinter()
     assert p.text_pretty == ""
     p.text("stuff")
@@ -24,7 +24,7 @@ def test_fake_printer():
     assert p.text_pretty == "stuff more"
 
 
-def test_assert_repr_pretty():
+def test_assert_repr_pretty() -> None:
     class TestClass:
         def _repr_pretty_(self, p, cycle):
             p.text("TestClass" if cycle else "I'm so pretty")
@@ -44,7 +44,7 @@ def test_assert_repr_pretty():
     cirq.testing.assert_repr_pretty(TestClassMultipleTexts(), "TestClass", cycle=True)
 
 
-def test_assert_repr_pretty_contains():
+def test_assert_repr_pretty_contains() -> None:
     class TestClass:
         def _repr_pretty_(self, p, cycle):
             p.text("TestClass" if cycle else "I'm so pretty")

cirq/testing/routing_devices_test.py

@@ -17,7 +17,7 @@ import pytest
 import cirq
 
 
-def test_grid_device():
+def test_grid_device() -> None:
     rect_device = cirq.testing.construct_grid_device(5, 7)
     rect_device_graph = rect_device.metadata.nx_graph
     isomorphism_class = nx.Graph()
@@ -33,7 +33,7 @@ def test_grid_device():
     assert nx.is_isomorphic(isomorphism_class, rect_device_graph)
 
 
-def test_grid_op_validation():
+def test_grid_op_validation() -> None:
     device = cirq.testing.construct_grid_device(5, 7)
 
     with pytest.raises(ValueError, match="Qubits not on device"):
@@ -56,7 +56,7 @@ def test_grid_op_validation():
     device.validate_operation(cirq.CNOT(cirq.GridQubit(0, 0), cirq.GridQubit(1, 0)))
 
 
-def test_ring_device():
+def test_ring_device() -> None:
     undirected_device = cirq.testing.construct_ring_device(5)
     undirected_device_graph = undirected_device.metadata.nx_graph
     assert all(q in undirected_device_graph.nodes for q in cirq.LineQubit.range(5))
@@ -74,7 +74,7 @@ def test_ring_device():
     assert nx.is_isomorphic(isomorphism_class, directed_device_graph)
 
 
-def test_ring_op_validation():
+def test_ring_op_validation() -> None:
     directed_device = cirq.testing.construct_ring_device(5, directed=True)
     undirected_device = cirq.testing.construct_ring_device(5, directed=False)
 
@@ -93,7 +93,7 @@ def test_ring_op_validation():
     directed_device.validate_operation(cirq.CNOT(cirq.LineQubit(0), cirq.LineQubit(1)))
 
 
-def test_allowed_multi_qubit_gates():
+def test_allowed_multi_qubit_gates() -> None:
     device = cirq.testing.construct_ring_device(5)
 
     device.validate_operation(cirq.MeasurementGate(1).on(cirq.LineQubit(0)))
@@ -106,7 +106,7 @@ def test_allowed_multi_qubit_gates():
     device.validate_operation(cirq.CNOT(*cirq.LineQubit.range(2)))
 
 
-def test_namedqubit_device():
+def test_namedqubit_device() -> None:
     # 4-star graph
     nx_graph = nx.Graph([("a", "b"), ("a", "c"), ("a", "d")])
 

cirq/testing/sample_circuits_test.py

@@ -15,7 +15,7 @@
 import cirq
 
 
-def test_nonoptimal_toffoli_circuit():
+def test_nonoptimal_toffoli_circuit() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.testing.nonoptimal_toffoli_circuit(q0, q1, q2).unitary(),

cirq/testing/sample_gates_test.py

@@ -19,7 +19,7 @@ from cirq.testing import sample_gates
 
 
 @pytest.mark.parametrize('theta', np.linspace(0, 2 * np.pi, 20))
-def test_phase_using_clean_ancilla(theta: float):
+def test_phase_using_clean_ancilla(theta: float) -> None:
     g = sample_gates.PhaseUsingCleanAncilla(theta)
     q = cirq.LineQubit(0)
     qubit_order = cirq.QubitOrder.explicit([q], fallback=cirq.QubitOrder.DEFAULT)
@@ -45,7 +45,7 @@ def test_phase_using_clean_ancilla(theta: float):
     'target_bitsize, phase_state', [(1, 0), (1, 1), (2, 0), (2, 1), (2, 2), (2, 3)]
 )
 @pytest.mark.parametrize('ancilla_bitsize', [1, 4])
-def test_phase_using_dirty_ancilla(target_bitsize, phase_state, ancilla_bitsize):
+def test_phase_using_dirty_ancilla(target_bitsize, phase_state, ancilla_bitsize) -> None:
     g = sample_gates.PhaseUsingDirtyAncilla(phase_state, target_bitsize, ancilla_bitsize)
     q = cirq.LineQubit.range(target_bitsize)
     qubit_order = cirq.QubitOrder.explicit(q, fallback=cirq.QubitOrder.DEFAULT)

cirq/transformers/analytical_decompositions/pauli_string_decomposition_test.py

@@ -28,7 +28,7 @@ from cirq.transformers.analytical_decompositions import unitary_to_pauli_string
 @pytest.mark.parametrize(
     'pauli_string', [''.join(p) for p in itertools.product(['', 'I', 'X', 'Y', 'Z'], repeat=4)]
 )
-def test_unitary_to_pauli_string(pauli_string: str, phase: complex):
+def test_unitary_to_pauli_string(pauli_string: str, phase: complex) -> None:
     want = DensePauliString(pauli_string, coefficient=phase)
     got = unitary_to_pauli_string(protocols.unitary(want))
     assert got is not None
@@ -36,7 +36,7 @@ def test_unitary_to_pauli_string(pauli_string: str, phase: complex):
     assert np.isclose(cast(np.complex128, want.coefficient), cast(np.complex128, got.coefficient))
 
 
-def test_unitary_to_pauli_string_non_pauli_input():
+def test_unitary_to_pauli_string_non_pauli_input() -> None:
     got = unitary_to_pauli_string(protocols.unitary(T))
     assert got is None
 
@@ -50,7 +50,7 @@ def test_unitary_to_pauli_string_non_pauli_input():
     assert got is None
 
 
-def test_invalid_input():
+def test_invalid_input() -> None:
     with pytest.raises(ValueError, match='Input has a non-square shape.*'):
         _ = unitary_to_pauli_string(np.zeros((2, 3)))
 

cirq/transformers/analytical_decompositions/three_qubit_decomposition_test.py

@@ -52,7 +52,7 @@ def _skip_if_scipy(*, version_is_greater_than_1_5_0: bool) -> Callable[[Callable
         cirq.CCX._unitary_(),
     ],
 )
-def test_three_qubit_matrix_to_operations(u):
+def test_three_qubit_matrix_to_operations(u) -> None:
     a, b, c = cirq.LineQubit.range(3)
     operations = cirq.three_qubit_matrix_to_operations(a, b, c, u)
     final_circuit = cirq.Circuit(operations)
@@ -69,7 +69,7 @@ def test_three_qubit_matrix_to_operations(u):
 
 
 @_skip_if_scipy(version_is_greater_than_1_5_0=False)
-def test_three_qubit_matrix_to_operations_errors():
+def test_three_qubit_matrix_to_operations_errors() -> None:
     a, b, c = cirq.LineQubit.range(3)
     with pytest.raises(ValueError, match="(8,8)"):
         cirq.three_qubit_matrix_to_operations(a, b, c, np.eye(2))
@@ -82,7 +82,7 @@ def test_three_qubit_matrix_to_operations_errors():
 # environment like that, we'll need to ignore the coverage somehow conditionally on
 # the scipy version.
 @_skip_if_scipy(version_is_greater_than_1_5_0=True)
-def test_three_qubit_matrix_to_operations_scipy_error():  # pragma: no cover
+def test_three_qubit_matrix_to_operations_scipy_error() -> None:  # pragma: no cover
     a, b, c = cirq.LineQubit.range(3)
     with pytest.raises(ImportError, match="three_qubit.*1.5.0+"):
         cirq.three_qubit_matrix_to_operations(a, b, c, np.eye(8))
@@ -100,7 +100,7 @@ def test_three_qubit_matrix_to_operations_scipy_error():  # pragma: no cover
         (np.array([0.3, 0.3, -0.3, -0.3]), 2),
     ],
 )
-def test_cs_to_ops(theta, num_czs):
+def test_cs_to_ops(theta, num_czs) -> None:
     a, b, c = cirq.LineQubit.range(3)
     cs = _theta_to_cs(theta)
     circuit_cs = cirq.Circuit(_cs_to_ops(a, b, c, theta))
@@ -126,7 +126,7 @@ def _theta_to_cs(theta: np.ndarray) -> np.ndarray:
     return np.block([[c, -s], [s, c]])
 
 
-def test_multiplexed_angles():
+def test_multiplexed_angles() -> None:
     theta = [random() * np.pi, random() * np.pi, random() * np.pi, random() * np.pi]
 
     angles = _multiplexed_angles(theta)
@@ -190,7 +190,7 @@ def test_multiplexed_angles():
         [([-0.3, 0.3, -0.3, -0.3]), 4],
     ],
 )
-def test_middle_multiplexor(angles, num_cnots):
+def test_middle_multiplexor(angles, num_cnots) -> None:
     a, b, c = cirq.LineQubit.range(3)
     eigvals = np.exp(np.array(angles) * np.pi * 1j)
     d = np.diag(np.sqrt(eigvals))
@@ -212,7 +212,7 @@ def test_middle_multiplexor(angles, num_cnots):
 
 
 @pytest.mark.parametrize("shift_left", [True, False])
-def test_two_qubit_multiplexor_to_circuit(shift_left):
+def test_two_qubit_multiplexor_to_circuit(shift_left) -> None:
     a, b, c = cirq.LineQubit.range(3)
     u1 = cirq.testing.random_unitary(4)
     u2 = cirq.testing.random_unitary(4)

cirq/transformers/analytical_decompositions/two_qubit_to_cz_test.py

@@ -52,7 +52,7 @@ from cirq.transformers.analytical_decompositions.two_qubit_to_cz import (
         ]
     )(1e-8 * 2 / 3, 1e-8 * 4 / 3),
 )
-def test_is_trivial_angle(rad, expected):
+def test_is_trivial_angle(rad, expected) -> None:
     tolerance = 1e-8
     out = _is_trivial_angle(rad, tolerance)
     assert out == expected, f'rad = {rad}'
@@ -163,7 +163,7 @@ def test_two_to_ops_equivalent_and_bounded_for_known_and_random(
     assert_cz_depth_below(operations_with_full, max_full_cz_depth, True)
 
 
-def test_trivial_parity_interaction_corner_case():
+def test_trivial_parity_interaction_corner_case() -> None:
     q0 = cirq.NamedQubit('q0')
     q1 = cirq.NamedQubit('q1')
     nearPi4 = np.pi / 4 * 0.99
@@ -172,7 +172,7 @@ def test_trivial_parity_interaction_corner_case():
     assert len(circuit) == 2
 
 
-def test_kak_decomposition_depth_full_cz():
+def test_kak_decomposition_depth_full_cz() -> None:
     a, b = cirq.LineQubit.range(2)
 
     # Random.
@@ -210,7 +210,7 @@ def test_kak_decomposition_depth_full_cz():
     assert len(c) <= 4
 
 
-def test_kak_decomposition_depth_partial_cz():
+def test_kak_decomposition_depth_partial_cz() -> None:
     a, b = cirq.LineQubit.range(2)
 
     # Random.
@@ -250,7 +250,7 @@ def test_kak_decomposition_depth_partial_cz():
         np.diag(np.exp(1j * np.pi * np.random.random(4))),
     ],
 )
-def test_decompose_to_diagonal_and_circuit(v):
+def test_decompose_to_diagonal_and_circuit(v) -> None:
     b, c = cirq.LineQubit.range(2)
     diagonal, ops = two_qubit_matrix_to_diagonal_and_cz_operations(b, c, v, atol=1e-8)
     assert cirq.is_diagonal(diagonal)
@@ -259,7 +259,7 @@ def test_decompose_to_diagonal_and_circuit(v):
     cirq.testing.assert_allclose_up_to_global_phase(circuit_unitary, v, atol=2e-6)
 
 
-def test_remove_partial_czs_or_fail():
+def test_remove_partial_czs_or_fail() -> None:
     CZ = cirq.CZ(*cirq.LineQubit.range(2))
     assert (
         cirq.transformers.analytical_decompositions.two_qubit_to_cz._remove_partial_czs_or_fail(

cirq/transformers/analytical_decompositions/two_qubit_to_fsim_test.py

@@ -65,7 +65,7 @@ FEASIBLE_FSIM_GATES = [
 
 
 @pytest.mark.parametrize('obj', UNITARY_OBJS)
-def test_decompose_two_qubit_interaction_into_two_b_gates(obj: Any):
+def test_decompose_two_qubit_interaction_into_two_b_gates(obj: Any) -> None:
     circuit = cirq.Circuit(
         _decompose_two_qubit_interaction_into_two_b_gates(obj, qubits=cirq.LineQubit.range(2))
     )
@@ -75,7 +75,7 @@ def test_decompose_two_qubit_interaction_into_two_b_gates(obj: Any):
     np.testing.assert_allclose(cirq.unitary(circuit), desired_unitary, atol=1e-6)
 
 
-def test_decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops_fail():
+def test_decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops_fail() -> None:
     c = _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
         qubits=cirq.LineQubit.range(2),
         fsim_gate=cirq.FSimGate(theta=np.pi / 2, phi=0),
@@ -108,7 +108,7 @@ def test_decompose_two_qubit_interaction_into_four_fsim_gates_equivalence(
     assert cirq.approx_eq(circuit.unitary(qubit_order=qubits), desired_unitary, atol=1e-4)
 
 
-def test_decompose_two_qubit_interaction_into_four_fsim_gates_validate():
+def test_decompose_two_qubit_interaction_into_four_fsim_gates_validate() -> None:
     iswap = cirq.FSimGate(theta=np.pi / 2, phi=0)
     with pytest.raises(ValueError, match='fsim_gate.theta'):
         cirq.decompose_two_qubit_interaction_into_four_fsim_gates(
@@ -127,7 +127,7 @@ def test_decompose_two_qubit_interaction_into_four_fsim_gates_validate():
         cirq.decompose_two_qubit_interaction_into_four_fsim_gates(np.eye(4), fsim_gate=fsim)
 
 
-def test_decompose_two_qubit_interaction_into_four_fsim_gates():
+def test_decompose_two_qubit_interaction_into_four_fsim_gates() -> None:
     iswap = cirq.FSimGate(theta=np.pi / 2, phi=0)
 
     # Defaults to line qubits.
@@ -153,7 +153,7 @@ def test_decompose_two_qubit_interaction_into_four_fsim_gates():
     assert set(c.all_qubits()) == set(cirq.LineQubit.range(10, 12))
 
 
-def test_sticky_0_to_1():
+def test_sticky_0_to_1() -> None:
     assert _sticky_0_to_1(-1, atol=1e-8) is None
 
     assert _sticky_0_to_1(-1e-6, atol=1e-8) is None