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

cirq/ops/phased_iswap_gate_test.py

@@ -22,7 +22,7 @@ import cirq
 np.set_printoptions(linewidth=300)
 
 
-def test_phased_iswap_init():
+def test_phased_iswap_init() -> None:
     p = -0.25
     t = 0.75
     s = 0.5
@@ -32,7 +32,7 @@ def test_phased_iswap_init():
     assert gate.global_shift == s
 
 
-def test_phased_iswap_equality():
+def test_phased_iswap_equality() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.PhasedISwapPowGate(phase_exponent=0, exponent=0.4))
     eq.add_equality_group(cirq.ISWAP**0.4)
@@ -40,7 +40,7 @@ def test_phased_iswap_equality():
     eq.add_equality_group(cirq.ISwapPowGate(global_shift=0.3) ** 0.4)
 
 
-def test_repr():
+def test_repr() -> None:
     p = -0.25
     t = 0.75
     s = 0.3
@@ -48,7 +48,7 @@ def test_repr():
     cirq.testing.assert_equivalent_repr(gate)
 
 
-def test_phased_iswap_unitary():
+def test_phased_iswap_unitary() -> None:
     p = 0.3
     t = 0.4
     actual = cirq.unitary(cirq.PhasedISwapPowGate(phase_exponent=p, exponent=t))
@@ -64,7 +64,7 @@ def test_phased_iswap_unitary():
     assert np.allclose(actual, expected)
 
 
-def test_phased_iswap_equivalent_circuit():
+def test_phased_iswap_equivalent_circuit() -> None:
     p = 0.7
     t = -0.4
     gate = cirq.PhasedISwapPowGate(phase_exponent=p, exponent=t)
@@ -81,7 +81,7 @@ def test_phased_iswap_equivalent_circuit():
     assert np.allclose(cirq.unitary(gate), cirq.unitary(equivalent_circuit))
 
 
-def test_phased_iswap_str():
+def test_phased_iswap_str() -> None:
     assert str(cirq.PhasedISwapPowGate(exponent=1)) == 'PhasedISWAP'
     assert str(cirq.PhasedISwapPowGate(exponent=0.5)) == 'PhasedISWAP**0.5'
     assert (
@@ -90,7 +90,7 @@ def test_phased_iswap_str():
     )
 
 
-def test_phased_iswap_pow():
+def test_phased_iswap_pow() -> None:
     gate1 = cirq.PhasedISwapPowGate(phase_exponent=0.1, exponent=0.25)
     gate2 = cirq.PhasedISwapPowGate(phase_exponent=0.1, exponent=0.5)
     assert gate1**2 == gate2
@@ -108,7 +108,7 @@ def test_phased_iswap_pow():
     assert np.allclose(u1 @ u1, u2)
 
 
-def test_decompose_invalid_qubits():
+def test_decompose_invalid_qubits() -> None:
     qs = cirq.LineQubit.range(3)
     with pytest.raises(ValueError):
         cirq.protocols.decompose_once_with_qubits(cirq.PhasedISwapPowGate(), qs)
@@ -134,7 +134,7 @@ def test_decompose_invalid_qubits():
         (sympy.Symbol('t'), sympy.Symbol('p'), 1),
     ],
 )
-def test_phased_iswap_has_consistent_protocols(phase_exponent, exponent, global_shift):
+def test_phased_iswap_has_consistent_protocols(phase_exponent, exponent, global_shift) -> None:
     cirq.testing.assert_implements_consistent_protocols(
         cirq.PhasedISwapPowGate(
             phase_exponent=phase_exponent, exponent=exponent, global_shift=global_shift
@@ -142,7 +142,7 @@ def test_phased_iswap_has_consistent_protocols(phase_exponent, exponent, global_
     )
 
 
-def test_diagram():
+def test_diagram() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     c = cirq.Circuit(
         cirq.PhasedISwapPowGate(phase_exponent=sympy.Symbol('p'), exponent=sympy.Symbol('t')).on(
@@ -165,7 +165,7 @@ def test_diagram():
 
 
 @pytest.mark.parametrize('angle_rads', (-np.pi, -np.pi / 3, -0.1, np.pi / 5))
-def test_givens_rotation_unitary(angle_rads):
+def test_givens_rotation_unitary(angle_rads) -> None:
     actual = cirq.unitary(cirq.givens(angle_rads))
     c = np.cos(angle_rads)
     s = np.sin(angle_rads)
@@ -179,7 +179,7 @@ def test_givens_rotation_unitary(angle_rads):
 
 
 @pytest.mark.parametrize('angle_rads', (-2 * np.pi / 3, -0.2, 0.4, np.pi / 4))
-def test_givens_rotation_hamiltonian(angle_rads):
+def test_givens_rotation_hamiltonian(angle_rads) -> None:
     actual = cirq.unitary(cirq.givens(angle_rads))
     x = np.array([[0, 1], [1, 0]])
     y = np.array([[0, -1j], [1j, 0]])
@@ -189,7 +189,7 @@ def test_givens_rotation_hamiltonian(angle_rads):
     assert np.allclose(actual, expected)
 
 
-def test_givens_rotation_equivalent_circuit():
+def test_givens_rotation_equivalent_circuit() -> None:
     angle_rads = 3 * np.pi / 7
     t = 2 * angle_rads / np.pi
     gate = cirq.givens(angle_rads)
@@ -201,11 +201,11 @@ def test_givens_rotation_equivalent_circuit():
 
 
 @pytest.mark.parametrize('angle_rads', (-np.pi / 5, 0.4, 2, np.pi))
-def test_givens_rotation_has_consistent_protocols(angle_rads):
+def test_givens_rotation_has_consistent_protocols(angle_rads) -> None:
     cirq.testing.assert_implements_consistent_protocols(cirq.givens(angle_rads))
 
 
-def test_approx_eq():
+def test_approx_eq() -> None:
     gate0 = cirq.PhasedISwapPowGate(phase_exponent=0)
     gate1 = cirq.PhasedISwapPowGate(phase_exponent=1e-12)
     gate2 = cirq.PhasedISwapPowGate(phase_exponent=2e-12)

cirq/ops/qubit_manager_test.py

@@ -18,7 +18,7 @@ import cirq
 from cirq.ops import qubit_manager as cqi
 
 
-def test_clean_qubits():
+def test_clean_qubits() -> None:
     q = cqi.CleanQubit(1)
     assert q.id == 1
     assert q.dimension == 2
@@ -39,7 +39,7 @@ def test_clean_qubits():
     assert cqi.CleanQubit(1) < cqi.CleanQubit(2)
 
 
-def test_ancilla_qubits_prefix():
+def test_ancilla_qubits_prefix() -> None:
     assert cqi.CleanQubit(1, prefix="1") != cqi.CleanQubit(1, prefix="2")
     assert cqi.CleanQubit(1, prefix="1") < cqi.CleanQubit(1, prefix="2")
     assert cqi.CleanQubit(1, prefix="1") < cqi.CleanQubit(2, prefix="1")
@@ -49,7 +49,7 @@ def test_ancilla_qubits_prefix():
     assert cqi.CleanQubit(1, prefix="1") != cqi.BorrowableQubit(1, prefix="1")
 
 
-def test_borrow_qubits():
+def test_borrow_qubits() -> None:
     q = cqi.BorrowableQubit(10)
     assert q.id == 10
     assert q.dimension == 2
@@ -71,7 +71,7 @@ def test_borrow_qubits():
 
 
 @pytest.mark.parametrize('_', range(2))
-def test_simple_qubit_manager(_):
+def test_simple_qubit_manager(_) -> None:
     qm = cirq.ops.SimpleQubitManager()
     assert qm.qalloc(1) == [cqi.CleanQubit(0)]
     assert qm.qalloc(2) == [cqi.CleanQubit(1), cqi.CleanQubit(2)]

cirq/ops/random_gate_channel_test.py

@@ -18,7 +18,7 @@ import sympy
 import cirq
 
 
-def test_init():
+def test_init() -> None:
     p = cirq.RandomGateChannel(sub_gate=cirq.X, probability=0.5)
     assert p.sub_gate is cirq.X
     assert p.probability == 0.5
@@ -29,7 +29,7 @@ def test_init():
         _ = cirq.RandomGateChannel(sub_gate=cirq.X, probability=-1)
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     q = cirq.LineQubit(0)
 
@@ -67,7 +67,7 @@ def test_eq():
     )
 
 
-def test_consistent_protocols():
+def test_consistent_protocols() -> None:
     cirq.testing.assert_implements_consistent_protocols(
         cirq.RandomGateChannel(sub_gate=cirq.X, probability=1),
         ignore_decompose_to_default_gateset=True,
@@ -86,7 +86,7 @@ def test_consistent_protocols():
     )
 
 
-def test_diagram():
+def test_diagram() -> None:
     class NoDetailsGate(cirq.Gate):
         def num_qubits(self) -> int:
             raise NotImplementedError()
@@ -115,7 +115,7 @@ def test_diagram():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_parameterized(resolve_fn):
+def test_parameterized(resolve_fn) -> None:
     op = cirq.X.with_probability(sympy.Symbol('x'))
     assert cirq.is_parameterized(op)
     assert not cirq.has_kraus(op)
@@ -128,7 +128,7 @@ def test_parameterized(resolve_fn):
     assert cirq.has_mixture(op2)
 
 
-def test_mixture():
+def test_mixture() -> None:
     class NoDetailsGate(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -150,7 +150,7 @@ def test_mixture():
     assert {p for p, _ in m} == {7 / 8, 1 / 32, 3 / 32}
 
 
-def test_channel():
+def test_channel() -> None:
     class NoDetailsGate(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -192,7 +192,7 @@ def test_channel():
     np.testing.assert_allclose(m[2], cirq.unitary(cirq.I) * np.sqrt(0.75), atol=1e-8)
 
 
-def test_trace_distance():
+def test_trace_distance() -> None:
     t = cirq.trace_distance_bound
     assert 0.999 <= t(cirq.X.with_probability(sympy.Symbol('x')))
     assert t(cirq.X.with_probability(0)) == 0
@@ -201,18 +201,18 @@ def test_trace_distance():
     assert 0.35 <= t(cirq.S.with_probability(0.5)) <= 0.36
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.X.with_probability(0.5)) == 'X[prob=0.5]'
 
 
-def test_stabilizer_supports_probability():
+def test_stabilizer_supports_probability() -> None:
     q = cirq.LineQubit(0)
     c = cirq.Circuit(cirq.X(q).with_probability(0.5), cirq.measure(q, key='m'))
     m = np.sum(cirq.StabilizerSampler().sample(c, repetitions=100)['m'])
     assert 5 < m < 95
 
 
-def test_unsupported_stabilizer_safety():
+def test_unsupported_stabilizer_safety() -> None:
     from cirq.protocols.act_on_protocol_test import ExampleSimulationState
 
     with pytest.raises(TypeError, match="act_on"):

cirq/ops/state_preparation_channel_test.py

@@ -36,7 +36,7 @@ import cirq
         ]
     ),
 )
-def test_state_prep_channel_kraus(state):
+def test_state_prep_channel_kraus(state) -> None:
     qubits = cirq.LineQubit.range(2)
     gate = cirq.StatePreparationChannel(state)(qubits[0], qubits[1])
     cirq.testing.assert_consistent_channel(gate)
@@ -53,7 +53,7 @@ def test_state_prep_channel_kraus(state):
     )
 
 
-def test_state_prep_channel_kraus_small():
+def test_state_prep_channel_kraus_small() -> None:
     gate = cirq.StatePreparationChannel(np.array([0.0, 1.0]))(cirq.LineQubit(0))
     np.testing.assert_almost_equal(
         cirq.kraus(gate), (np.array([[0.0, 0.0], [1.0, 0.0]]), np.array([[0.0, 0.0], [0.0, 1.0]]))
@@ -69,7 +69,7 @@ def test_state_prep_channel_kraus_small():
     assert not cirq.has_mixture(gate)
 
 
-def test_state_prep_gate_printing():
+def test_state_prep_gate_printing() -> None:
     circuit = cirq.Circuit()
     qubits = cirq.LineQubit.range(2)
     gate = cirq.StatePreparationChannel(np.array([1, 0, 0, 1]) / np.sqrt(2))
@@ -87,7 +87,7 @@ def test_state_prep_gate_printing():
 
 
 @pytest.mark.parametrize('name', ['Prep', 'S'])
-def test_state_prep_gate_printing_with_name(name):
+def test_state_prep_gate_printing_with_name(name) -> None:
     circuit = cirq.Circuit()
     qubits = cirq.LineQubit.range(2)
     gate = cirq.StatePreparationChannel(np.array([1, 0, 0, 1]) / np.sqrt(2), name=name)
@@ -104,7 +104,7 @@ def test_state_prep_gate_printing_with_name(name):
     )
 
 
-def test_gate_params():
+def test_gate_params() -> None:
     state = np.array([1, 0, 0, 0], dtype=np.complex64)
     gate = cirq.StatePreparationChannel(state)
     assert gate.num_qubits() == 2
@@ -114,14 +114,14 @@ def test_gate_params():
     cirq.testing.assert_equivalent_repr(gate)
 
 
-def test_gate_error_handling():
+def test_gate_error_handling() -> None:
     with pytest.raises(ValueError, match='`target_state` must be a 1d numpy array.'):
         cirq.StatePreparationChannel(np.eye(2))
     with pytest.raises(ValueError, match='Matrix width \\(5\\) is not a power of 2'):
         cirq.StatePreparationChannel(np.ones(shape=5))
 
 
-def test_equality_of_gates():
+def test_equality_of_gates() -> None:
     state = np.array([1, 0, 0, 0], dtype=np.complex64)
     gate_1 = cirq.StatePreparationChannel(state)
     gate_2 = cirq.StatePreparationChannel(state)
@@ -134,7 +134,7 @@ def test_equality_of_gates():
     assert gate_1 != gate_3, "Different states shouldn't lead to same gate"
 
 
-def test_approx_equality_of_gates():
+def test_approx_equality_of_gates() -> None:
     state = np.array([1, 0, 0, 0], dtype=np.complex64)
     gate_1 = cirq.StatePreparationChannel(state)
     gate_2 = cirq.StatePreparationChannel(state)

cirq/ops/swap_gates_test.py

@@ -21,11 +21,11 @@ import cirq
 
 
 @pytest.mark.parametrize('eigen_gate_type', [cirq.ISwapPowGate, cirq.SwapPowGate])
-def test_phase_sensitive_eigen_gates_consistent_protocols(eigen_gate_type):
+def test_phase_sensitive_eigen_gates_consistent_protocols(eigen_gate_type) -> None:
     cirq.testing.assert_eigengate_implements_consistent_protocols(eigen_gate_type)
 
 
-def test_interchangeable_qubit_eq():
+def test_interchangeable_qubit_eq() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -44,7 +44,7 @@ def test_interchangeable_qubit_eq():
     eq.add_equality_group(cirq.ISWAP(a, c) ** 0.3)
 
 
-def test_text_diagrams():
+def test_text_diagrams() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     circuit = cirq.Circuit(cirq.SWAP(a, b), cirq.ISWAP(a, b) ** -1)
@@ -69,14 +69,14 @@ b: ---Swap---iSwap^-1---
     )
 
 
-def test_swap_has_stabilizer_effect():
+def test_swap_has_stabilizer_effect() -> None:
     assert cirq.has_stabilizer_effect(cirq.SWAP)
     assert cirq.has_stabilizer_effect(cirq.SWAP**2)
     assert not cirq.has_stabilizer_effect(cirq.SWAP**0.5)
     assert not cirq.has_stabilizer_effect(cirq.SWAP ** sympy.Symbol('foo'))
 
 
-def test_swap_unitary():
+def test_swap_unitary() -> None:
     # yapf: disable
     np.testing.assert_almost_equal(
         cirq.unitary(cirq.SWAP**0.5),
@@ -89,7 +89,7 @@ def test_swap_unitary():
     # yapf: enable
 
 
-def test_iswap_unitary():
+def test_iswap_unitary() -> None:
     # yapf: disable
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.unitary(cirq.ISWAP),
@@ -103,7 +103,7 @@ def test_iswap_unitary():
     # yapf: enable
 
 
-def test_iswap_inv_unitary():
+def test_iswap_inv_unitary() -> None:
     # yapf: disable
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.unitary(cirq.ISWAP_INV),
@@ -117,7 +117,7 @@ def test_iswap_inv_unitary():
     # yapf: enable
 
 
-def test_sqrt_iswap_unitary():
+def test_sqrt_iswap_unitary() -> None:
     # yapf: disable
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.unitary(cirq.SQRT_ISWAP),
@@ -131,7 +131,7 @@ def test_sqrt_iswap_unitary():
     # yapf: enable
 
 
-def test_sqrt_iswap_inv_unitary():
+def test_sqrt_iswap_inv_unitary() -> None:
     # yapf: disable
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.unitary(cirq.SQRT_ISWAP_INV),
@@ -145,7 +145,7 @@ def test_sqrt_iswap_inv_unitary():
     # yapf: enable
 
 
-def test_repr():
+def test_repr() -> None:
     assert repr(cirq.SWAP) == 'cirq.SWAP'
     assert repr(cirq.SWAP**0.5) == '(cirq.SWAP**0.5)'
 
@@ -156,7 +156,7 @@ def test_repr():
     assert repr(cirq.ISWAP_INV**0.5) == '(cirq.ISWAP**-0.5)'
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.SWAP) == 'SWAP'
     assert str(cirq.SWAP**0.5) == 'SWAP**0.5'
 
@@ -167,7 +167,7 @@ def test_str():
     assert str(cirq.ISWAP_INV**0.5) == 'ISWAP**-0.5'
 
 
-def test_iswap_decompose_diagram():
+def test_iswap_decompose_diagram() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -182,7 +182,7 @@ b: ───X───────@───────@───────
     )
 
 
-def test_trace_distance():
+def test_trace_distance() -> None:
     foo = sympy.Symbol('foo')
     sswap = cirq.SWAP**foo
     siswap = cirq.ISWAP**foo
@@ -194,14 +194,14 @@ def test_trace_distance():
     assert cirq.approx_eq(cirq.trace_distance_bound(cirq.ISWAP**0), 0.0)
 
 
-def test_trace_distance_over_range_of_exponents():
+def test_trace_distance_over_range_of_exponents() -> None:
     for exp in np.linspace(0, 4, 20):
         cirq.testing.assert_has_consistent_trace_distance_bound(cirq.SWAP**exp)
         cirq.testing.assert_has_consistent_trace_distance_bound(cirq.ISWAP**exp)
 
 
 @pytest.mark.parametrize('angle_rads', (-np.pi, -np.pi / 3, -0.1, np.pi / 5))
-def test_riswap_unitary(angle_rads):
+def test_riswap_unitary(angle_rads) -> None:
     actual = cirq.unitary(cirq.riswap(angle_rads))
     c = np.cos(angle_rads)
     s = 1j * np.sin(angle_rads)
@@ -215,7 +215,7 @@ def test_riswap_unitary(angle_rads):
 
 
 @pytest.mark.parametrize('angle_rads', (-2 * np.pi / 3, -0.2, 0.4, np.pi / 4))
-def test_riswap_hamiltonian(angle_rads):
+def test_riswap_hamiltonian(angle_rads) -> None:
     actual = cirq.unitary(cirq.riswap(angle_rads))
     x = np.array([[0, 1], [1, 0]])
     y = np.array([[0, -1j], [1j, 0]])
@@ -226,5 +226,5 @@ def test_riswap_hamiltonian(angle_rads):
 
 
 @pytest.mark.parametrize('angle_rads', (-np.pi / 5, 0.4, 2, np.pi))
-def test_riswap_has_consistent_protocols(angle_rads):
+def test_riswap_has_consistent_protocols(angle_rads) -> None:
     cirq.testing.assert_implements_consistent_protocols(cirq.riswap(angle_rads))

cirq/ops/tags_test.py

@@ -15,7 +15,7 @@
 import cirq
 
 
-def test_virtual_tag():
+def test_virtual_tag() -> None:
     tag1 = cirq.ops.VirtualTag()
     tag2 = cirq.ops.VirtualTag()
 
@@ -26,7 +26,7 @@ def test_virtual_tag():
     cirq.testing.assert_equivalent_repr(tag2)
 
 
-def test_routing_swap_tag():
+def test_routing_swap_tag() -> None:
     tag1 = cirq.ops.RoutingSwapTag()
     tag2 = cirq.ops.RoutingSwapTag()
 

cirq/ops/three_qubit_gates_test.py

@@ -22,7 +22,7 @@ import cirq
 
 
 @pytest.mark.parametrize('eigen_gate_type', [cirq.CCXPowGate, cirq.CCZPowGate])
-def test_eigen_gates_consistent_protocols(eigen_gate_type):
+def test_eigen_gates_consistent_protocols(eigen_gate_type) -> None:
     cirq.testing.assert_eigengate_implements_consistent_protocols(eigen_gate_type)
 
 
@@ -36,18 +36,18 @@ def test_eigen_gates_consistent_protocols(eigen_gate_type):
         (cirq.CCZ),
     ),
 )
-def test_consistent_protocols(gate):
+def test_consistent_protocols(gate) -> None:
     cirq.testing.assert_implements_consistent_protocols(gate)
 
 
-def test_init():
+def test_init() -> None:
     assert (cirq.CCZ**0.5).exponent == 0.5
     assert (cirq.CCZ**0.25).exponent == 0.25
     assert (cirq.CCX**0.5).exponent == 0.5
     assert (cirq.CCX**0.25).exponent == 0.25
 
 
-def test_unitary():
+def test_unitary() -> None:
     assert cirq.has_unitary(cirq.CCX)
     np.testing.assert_allclose(
         cirq.unitary(cirq.CCX),
@@ -123,7 +123,7 @@ def test_unitary():
     )
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.CCX) == 'TOFFOLI'
     assert str(cirq.TOFFOLI) == 'TOFFOLI'
     assert str(cirq.CSWAP) == 'FREDKIN'
@@ -134,7 +134,7 @@ def test_str():
     assert str(cirq.CCZ**0.5) == 'CCZ**0.5'
 
 
-def test_repr():
+def test_repr() -> None:
     assert repr(cirq.CCX) == 'cirq.TOFFOLI'
     assert repr(cirq.TOFFOLI) == 'cirq.TOFFOLI'
     assert repr(cirq.CSWAP) == 'cirq.FREDKIN'
@@ -145,7 +145,7 @@ def test_repr():
     assert repr(cirq.CCZ**0.5) == '(cirq.CCZ**0.5)'
 
 
-def test_eq():
+def test_eq() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.CCZ(a, b, c), cirq.CCZ(a, c, b), cirq.CCZ(b, c, a))
@@ -163,7 +163,7 @@ def test_eq():
     eq.add_equality_group(cirq.CSWAP(b, a, c), cirq.CSWAP(b, c, a))
 
 
-def test_gate_equality():
+def test_gate_equality() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.CSwapGate(), cirq.CSwapGate())
     eq.add_equality_group(cirq.CZPowGate(), cirq.CZPowGate())
@@ -171,7 +171,7 @@ def test_gate_equality():
     eq.add_equality_group(cirq.CCZPowGate(), cirq.CCZPowGate())
 
 
-def test_identity_multiplication():
+def test_identity_multiplication() -> None:
     a, b, c = cirq.LineQubit.range(3)
     assert cirq.CCX(a, b, c) * cirq.I(a) == cirq.CCX(a, b, c)
     assert cirq.CCX(a, b, c) * cirq.I(b) == cirq.CCX(a, b, c)
@@ -197,7 +197,7 @@ def test_identity_multiplication():
         ),
     ],
 )
-def test_decomposition_cost(op: cirq.Operation, max_two_cost: int):
+def test_decomposition_cost(op: cirq.Operation, max_two_cost: int) -> None:
     ops = tuple(cirq.flatten_op_tree(cirq.decompose(op)))
     two_cost = len([e for e in ops if len(e.qubits) == 2])
     over_cost = len([e for e in ops if len(e.qubits) > 2])
@@ -205,12 +205,12 @@ def test_decomposition_cost(op: cirq.Operation, max_two_cost: int):
     assert two_cost == max_two_cost
 
 
-def test_parameterized_ccz_decompose_no_global_phase():
+def test_parameterized_ccz_decompose_no_global_phase() -> None:
     decomposed_ops = cirq.decompose(cirq.CCZ(*cirq.LineQubit.range(3)) ** sympy.Symbol("theta"))
     assert not any(isinstance(op.gate, cirq.GlobalPhaseGate) for op in decomposed_ops)
 
 
-def test_diagonal_gate_property():
+def test_diagonal_gate_property() -> None:
     assert cirq.ThreeQubitDiagonalGate([2, 3, 5, 7, 0, 0, 0, 1]).diag_angles_radians == (
         (2, 3, 5, 7, 0, 0, 0, 1)
     )
@@ -220,7 +220,7 @@ def test_diagonal_gate_property():
     'gate',
     [cirq.CCX, cirq.CSWAP, cirq.CCZ, cirq.ThreeQubitDiagonalGate([2, 3, 5, 7, 11, 13, 17, 19])],
 )
-def test_decomposition_respects_locality(gate):
+def test_decomposition_respects_locality(gate) -> None:
     a = cirq.GridQubit(0, 0)
     b = cirq.GridQubit(1, 0)
     c = cirq.GridQubit(0, 1)
@@ -231,7 +231,7 @@ def test_decomposition_respects_locality(gate):
         dev.validate_circuit(circuit)
 
 
-def test_diagram():
+def test_diagram() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     circuit = cirq.Circuit(
         cirq.TOFFOLI(a, b, c),
@@ -295,7 +295,7 @@ def test_diagram():
     )
 
 
-def test_diagonal_exponent():
+def test_diagonal_exponent() -> None:
     diagonal_angles = [2, 3, 5, 7, 11, 13, 17, 19]
     diagonal_gate = cirq.ThreeQubitDiagonalGate(diagonal_angles)
 
@@ -308,7 +308,7 @@ def test_diagonal_exponent():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve(resolve_fn):
+def test_resolve(resolve_fn) -> None:
     diagonal_angles = [2, 3, 5, 7, 11, 13, 17, 19]
     diagonal_gate = cirq.ThreeQubitDiagonalGate(
         diagonal_angles[:6] + [sympy.Symbol('a'), sympy.Symbol('b')]
@@ -325,7 +325,7 @@ def test_resolve(resolve_fn):
 
 
 @pytest.mark.parametrize('gate', [cirq.CCX, cirq.CCZ, cirq.CSWAP])
-def test_controlled_ops_consistency(gate):
+def test_controlled_ops_consistency(gate) -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     assert gate.controlled(0) is gate
     assert gate(a, b, c).controlled_by(d) == gate(d, b, c).controlled_by(a)

cirq/ops/two_qubit_diagonal_gate_test.py

@@ -30,15 +30,15 @@ import cirq
         )
     ),
 )
-def test_consistent_protocols(gate):
+def test_consistent_protocols(gate) -> None:
     cirq.testing.assert_implements_consistent_protocols(gate)
 
 
-def test_property():
+def test_property() -> None:
     assert cirq.TwoQubitDiagonalGate([2, 3, 5, 7]).diag_angles_radians == (2, 3, 5, 7)
 
 
-def test_parameterized_decompose():
+def test_parameterized_decompose() -> None:
     angles = sympy.symbols('x0, x1, x2, x3')
     parameterized_op = cirq.TwoQubitDiagonalGate(angles).on(*cirq.LineQubit.range(2))
     decomposed_circuit = cirq.Circuit(cirq.decompose(parameterized_op))
@@ -54,7 +54,7 @@ def test_parameterized_decompose():
         )
 
 
-def test_unitary():
+def test_unitary() -> None:
     diagonal_angles = [2, 3, 5, 7]
     assert cirq.has_unitary(cirq.TwoQubitDiagonalGate(diagonal_angles))
     np.testing.assert_allclose(
@@ -64,7 +64,7 @@ def test_unitary():
     )
 
 
-def test_diagram():
+def test_diagram() -> None:
     a, b = cirq.LineQubit.range(2)
 
     diagonal_circuit = cirq.Circuit(cirq.TwoQubitDiagonalGate([2, 3, 5, 7])(a, b))
@@ -87,7 +87,7 @@ def test_diagram():
     )
 
 
-def test_diagonal_exponent():
+def test_diagonal_exponent() -> None:
     diagonal_angles = [2, 3, 5, 7]
     diagonal_gate = cirq.TwoQubitDiagonalGate(diagonal_angles)
 
@@ -99,7 +99,7 @@ def test_diagonal_exponent():
     assert cirq.pow(cirq.TwoQubitDiagonalGate(diagonal_angles), "test", None) is None
 
 
-def test_protocols_mul_not_implemented():
+def test_protocols_mul_not_implemented() -> None:
     diagonal_angles = [2, 3, None, 7]
     diagonal_gate = cirq.TwoQubitDiagonalGate(diagonal_angles)
     with pytest.raises(TypeError):
@@ -107,7 +107,7 @@ def test_protocols_mul_not_implemented():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve(resolve_fn):
+def test_resolve(resolve_fn) -> None:
     diagonal_angles = [2, 3, 5, 7]
     diagonal_gate = cirq.TwoQubitDiagonalGate(
         diagonal_angles[:2] + [sympy.Symbol('a'), sympy.Symbol('b')]