cirq-core 1.7.0.dev20251002223432__py3-none-any.whl → 1.7.0.dev20251007180852__py3-none-any.whl

cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py

@@ -24,7 +24,7 @@ import sympy
 import cirq
 
 
-def test_symbols():
+def test_symbols() -> None:
     with pytest.raises(ValueError, match='Symbolic arguments'):
         cirq.compute_cphase_exponents_for_fsim_decomposition(
             cirq.FSimGate(theta=sympy.Symbol('t'), phi=sympy.Symbol('phi'))
@@ -36,8 +36,9 @@ class FakeSycamoreGate(cirq.FSimGate):
         super().__init__(theta=np.pi / 2, phi=np.pi / 6)
 
 
-def test_parameterized_gates():
+def test_parameterized_gates() -> None:
     t = sympy.Symbol('t')
+    fsim_gate: cirq.FSimGate
     with pytest.raises(ValueError):
         cphase_gate = cirq.CZPowGate(exponent=t)
         fsim_gate = FakeSycamoreGate()
@@ -54,14 +55,14 @@ def test_parameterized_gates():
         cirq.decompose_cphase_into_two_fsim(cphase_gate, fsim_gate=fsim_gate)
 
 
-def test_invalid_qubits():
+def test_invalid_qubits() -> None:
     with pytest.raises(ValueError):
         cirq.decompose_cphase_into_two_fsim(
             cphase_gate=cirq.CZ, fsim_gate=FakeSycamoreGate(), qubits=cirq.LineQubit.range(3)
         )
 
 
-def test_circuit_structure():
+def test_circuit_structure() -> None:
     syc = FakeSycamoreGate()
     ops = cirq.decompose_cphase_into_two_fsim(cirq.CZ, fsim_gate=syc)
     num_interaction_moments = 0
@@ -73,7 +74,7 @@ def test_circuit_structure():
     assert num_interaction_moments == 2
 
 
-def assert_decomposition_valid(cphase_gate, fsim_gate):
+def assert_decomposition_valid(cphase_gate, fsim_gate) -> None:
     u_expected = cirq.unitary(cphase_gate)
     ops = cirq.decompose_cphase_into_two_fsim(cphase_gate, fsim_gate=fsim_gate)
     u_actual = cirq.unitary(cirq.Circuit(ops))
@@ -83,7 +84,7 @@ def assert_decomposition_valid(cphase_gate, fsim_gate):
 @pytest.mark.parametrize(
     'exponent', (-5.5, -3, -1.5, -1, -0.65, -0.2, 0, 0.1, 0.75, 1, 1.5, 2, 5.5)
 )
-def test_decomposition_to_sycamore_gate(exponent):
+def test_decomposition_to_sycamore_gate(exponent) -> None:
     cphase_gate = cirq.CZPowGate(exponent=exponent)
     assert_decomposition_valid(cphase_gate, FakeSycamoreGate())
 
@@ -95,7 +96,7 @@ def test_decomposition_to_sycamore_gate(exponent):
         (-1.4 * np.pi, -np.pi / 9, np.pi / 11, np.pi / 2, 2.4 * np.pi),
     ),
 )
-def test_valid_cphase_exponents(theta, phi):
+def test_valid_cphase_exponents(theta, phi) -> None:
     fsim_gate = cirq.FSimGate(theta=theta, phi=phi)
     valid_exponent_intervals = cirq.compute_cphase_exponents_for_fsim_decomposition(fsim_gate)
     assert valid_exponent_intervals
@@ -131,7 +132,7 @@ def complement_intervals(intervals: Sequence[tuple[float, float]]) -> Sequence[t
         (-1.7 * np.pi, -np.pi / 5, np.pi / 7, 2.5 * np.pi),
     ),
 )
-def test_invalid_cphase_exponents(theta, phi):
+def test_invalid_cphase_exponents(theta, phi) -> None:
     fsim_gate = cirq.FSimGate(theta=theta, phi=phi)
     valid_exponent_intervals = cirq.compute_cphase_exponents_for_fsim_decomposition(fsim_gate)
     invalid_exponent_intervals = complement_intervals(valid_exponent_intervals)
@@ -151,6 +152,6 @@ def test_invalid_cphase_exponents(theta, phi):
 @pytest.mark.parametrize(
     'bad_fsim_gate', (cirq.FSimGate(theta=0, phi=0), cirq.FSimGate(theta=np.pi / 4, phi=np.pi / 2))
 )
-def test_invalid_fsim_gate(bad_fsim_gate):
+def test_invalid_fsim_gate(bad_fsim_gate) -> None:
     with pytest.raises(ValueError):
         cirq.decompose_cphase_into_two_fsim(cirq.CZ, fsim_gate=bad_fsim_gate)

cirq/transformers/analytical_decompositions/quantum_shannon_decomposition.py

@@ -21,7 +21,7 @@ https://arxiv.org/abs/quant-ph/0406176
 
 from __future__ import annotations
 
-from typing import Callable, cast, Iterable, TYPE_CHECKING
+from typing import Callable, cast, Iterable, Sequence, TYPE_CHECKING
 
 import numpy as np
 from attr import define
@@ -47,7 +47,7 @@ class _TwoQubitGate:
 
 
 def quantum_shannon_decomposition(
-    qubits: list[cirq.Qid], u: np.ndarray, atol: float = 1e-8
+    qubits: Sequence[cirq.Qid], u: np.ndarray, atol: float = 1e-8
 ) -> Iterable[cirq.Operation]:
     """Decomposes n-qubit unitary 1-q, 2-q and GlobalPhase gates, preserving global phase.
 
@@ -149,7 +149,7 @@ def quantum_shannon_decomposition(
     yield from cast(Iterable[ops.Operation], ops.flatten_op_tree(shannon_decomp))
 
 
-def _recursive_decomposition(qubits: list[cirq.Qid], u: np.ndarray) -> Iterable[cirq.Operation]:
+def _recursive_decomposition(qubits: Sequence[cirq.Qid], u: np.ndarray) -> Iterable[cirq.Operation]:
     """Recursive step in the quantum shannon decomposition.
 
     Decomposes n-qubit unitary into generic 2-qubit gates, CNOT, CZ and 1-qubit gates.
@@ -270,7 +270,7 @@ def _single_qubit_decomposition(qubit: cirq.Qid, u: np.ndarray) -> Iterable[cirq
 
 
 def _msb_demuxer(
-    demux_qubits: list[cirq.Qid], u1: np.ndarray, u2: np.ndarray
+    demux_qubits: Sequence[cirq.Qid], u1: np.ndarray, u2: np.ndarray
 ) -> Iterable[cirq.Operation]:
     """Demultiplexes a unitary matrix that is multiplexed in its most-significant-qubit.
 
@@ -336,7 +336,7 @@ def _nth_gray(n: int) -> int:
 
 
 def _multiplexed_cossin(
-    cossin_qubits: list[cirq.Qid], angles: list[float], rot_func: Callable = ops.ry
+    cossin_qubits: Sequence[cirq.Qid], angles: list[float], rot_func: Callable = ops.ry
 ) -> Iterable[cirq.Operation]:
     """Performs a multiplexed rotation over all qubits in this unitary matrix,
 

cirq/transformers/analytical_decompositions/quantum_shannon_decomposition_test.py

@@ -33,7 +33,7 @@ from cirq.transformers.analytical_decompositions.quantum_shannon_decomposition i
 
 @pytest.mark.xfail(reason='#6765')
 @pytest.mark.parametrize('n_qubits', list(range(1, 8)))
-def test_random_qsd_n_qubit(n_qubits):
+def test_random_qsd_n_qubit(n_qubits) -> None:
     U = unitary_group.rvs(2**n_qubits)
     qubits = [cirq.NamedQubit(f'q{i}') for i in range(n_qubits)]
     circuit = cirq.Circuit(quantum_shannon_decomposition(qubits, U))
@@ -43,7 +43,7 @@ def test_random_qsd_n_qubit(n_qubits):
     assert all(cirq.num_qubits(op) <= 2 for op in circuit.all_operations())
 
 
-def test_qsd_n_qubit_errors():
+def test_qsd_n_qubit_errors() -> None:
     qubits = [cirq.NamedQubit(f'q{i}') for i in range(3)]
     with pytest.raises(ValueError, match="shaped numpy array"):
         cirq.Circuit(quantum_shannon_decomposition(qubits, np.eye(9)))
@@ -51,7 +51,7 @@ def test_qsd_n_qubit_errors():
         cirq.Circuit(quantum_shannon_decomposition(qubits, np.ones((8, 8))))
 
 
-def test_recursive_decomposition_n_qubit_errors():
+def test_recursive_decomposition_n_qubit_errors() -> None:
     qubits = [cirq.NamedQubit(f'q{i}') for i in range(3)]
     with pytest.raises(ValueError, match="shaped numpy array"):
         cirq.Circuit(_recursive_decomposition(qubits, np.eye(9)))
@@ -59,7 +59,7 @@ def test_recursive_decomposition_n_qubit_errors():
         cirq.Circuit(_recursive_decomposition(qubits, np.eye(2)))
 
 
-def test_random_single_qubit_decomposition():
+def test_random_single_qubit_decomposition() -> None:
     U = unitary_group.rvs(2)
     qubit = cirq.NamedQubit('q0')
     circuit = cirq.Circuit(_single_qubit_decomposition(qubit, U))
@@ -69,7 +69,7 @@ def test_random_single_qubit_decomposition():
     assert all(cirq.num_qubits(op) <= 2 for op in circuit.all_operations())
 
 
-def test_msb_demuxer():
+def test_msb_demuxer() -> None:
     U1 = unitary_group.rvs(4)
     U2 = unitary_group.rvs(4)
     U_full = np.kron([[1, 0], [0, 0]], U1) + np.kron([[0, 0], [0, 1]], U2)
@@ -81,13 +81,12 @@ def test_msb_demuxer():
     assert all(cirq.num_qubits(op) <= 2 for op in circuit.all_operations())
 
 
-def test_multiplexed_cossin():
+def test_multiplexed_cossin() -> None:
     angle_1 = np.random.random_sample() * 2 * np.pi
     angle_2 = np.random.random_sample() * 2 * np.pi
     c1, s1 = np.cos(angle_1), np.sin(angle_1)
     c2, s2 = np.cos(angle_2), np.sin(angle_2)
-    multiplexed_ry = [[c1, 0, -s1, 0], [0, c2, 0, -s2], [s1, 0, c1, 0], [0, s2, 0, c2]]
-    multiplexed_ry = np.array(multiplexed_ry)
+    multiplexed_ry = np.asarray([[c1, 0, -s1, 0], [0, c2, 0, -s2], [s1, 0, c1, 0], [0, s2, 0, c2]])
     qubits = [cirq.NamedQubit(f'q{i}') for i in range(2)]
     circuit = cirq.Circuit(_multiplexed_cossin(qubits, [angle_1, angle_2]))
     # Add back the CZ gate removed by the A.1 optimization
@@ -126,11 +125,11 @@ def test_multiplexed_cossin():
         (15, 8),
     ],
 )
-def test_nth_gray(n, gray):
+def test_nth_gray(n, gray) -> None:
     assert _nth_gray(n) == gray
 
 
-def test_ghz_circuit_decomposes():
+def test_ghz_circuit_decomposes() -> None:
     # Test case from #6725
     ghz_circuit = cirq.Circuit(cirq.H(cirq.q(0)), cirq.CNOT(cirq.q(0), cirq.q(1)))
     ghz_unitary = cirq.unitary(ghz_circuit)
@@ -141,7 +140,7 @@ def test_ghz_circuit_decomposes():
     np.testing.assert_allclose(new_unitary, ghz_unitary, atol=1e-6)
 
 
-def test_qft_decomposes():
+def test_qft_decomposes() -> None:
     # Test case from #6666
     qs = cirq.LineQubit.range(4)
     qft_circuit = cirq.Circuit(cirq.qft(*qs))
@@ -163,7 +162,7 @@ def test_qft_decomposes():
         (cirq.S, 1),  # rz & ry
     ],
 )
-def test_cliffords(gate, num_ops):
+def test_cliffords(gate, num_ops) -> None:
     desired_unitary = cirq.unitary(gate)
     shannon_circuit = cirq.Circuit(quantum_shannon_decomposition((cirq.q(0),), desired_unitary))
     new_unitary = cirq.unitary(shannon_circuit)
@@ -173,7 +172,7 @@ def test_cliffords(gate, num_ops):
 
 
 @pytest.mark.parametrize('gate', [cirq.X, cirq.Y, cirq.Z, cirq.H, cirq.S])
-def test_cliffords_with_global_phase(gate):
+def test_cliffords_with_global_phase(gate) -> None:
     global_phase = np.exp(1j * np.random.choice(np.linspace(0.1, 2 * np.pi, 10)))
     desired_unitary = cirq.unitary(gate) * global_phase
     shannon_circuit = cirq.Circuit(quantum_shannon_decomposition((cirq.q(0),), desired_unitary))
@@ -181,7 +180,7 @@ def test_cliffords_with_global_phase(gate):
     np.testing.assert_allclose(new_unitary, desired_unitary)
 
 
-def test_global_phase():
+def test_global_phase() -> None:
     global_phase = np.exp(1j * np.random.choice(np.linspace(0, 2 * np.pi, 10)))
     shannon_circuit = cirq.Circuit(
         quantum_shannon_decomposition((cirq.q(0),), np.eye(2) * global_phase)
@@ -191,7 +190,7 @@ def test_global_phase():
 
 
 @pytest.mark.parametrize('gate', [cirq.CZ, cirq.CNOT, cirq.XX, cirq.YY, cirq.ZZ])
-def test_two_qubit_gate(gate):
+def test_two_qubit_gate(gate) -> None:
     global_phase = np.exp(1j * np.random.choice(np.linspace(0, 2 * np.pi, 10)))
     desired_unitary = cirq.unitary(gate) * global_phase
     shannon_circuit = cirq.Circuit(
@@ -202,7 +201,7 @@ def test_two_qubit_gate(gate):
 
 
 @pytest.mark.parametrize('gate', [cirq.CCNOT, cirq.qft(*cirq.LineQubit.range(3))])
-def test_three_qubit_gate(gate):
+def test_three_qubit_gate(gate) -> None:
     global_phase = np.exp(1j * np.random.choice(np.linspace(0, 2 * np.pi, 10)))
     desired_unitary = cirq.unitary(gate) * global_phase
     shannon_circuit = cirq.Circuit(
@@ -213,7 +212,7 @@ def test_three_qubit_gate(gate):
 
 
 @pytest.mark.xfail(reason='#6765')
-def test_qft5():
+def test_qft5() -> None:
     global_phase = np.exp(1j * np.random.choice(np.linspace(0, 2 * np.pi, 10)))
     desired_unitary = cirq.unitary(cirq.qft(*cirq.LineQubit.range(5))) * global_phase
     shannon_circuit = cirq.Circuit(
@@ -223,7 +222,7 @@ def test_qft5():
     np.testing.assert_allclose(new_unitary, desired_unitary, atol=1e-6)
 
 
-def test_random_circuit_decomposition():
+def test_random_circuit_decomposition() -> None:
     qubits = cirq.LineQubit.range(3)
     test_circuit = (
         random_two_qubit_circuit_with_czs(3, qubits[0], qubits[1])

cirq/transformers/analytical_decompositions/single_qubit_decompositions_test.py

@@ -25,13 +25,13 @@ import cirq
 
 
 def assert_gates_implement_unitary(
-    gates: Sequence[cirq.testing.SingleQubitGate], intended_effect: np.ndarray, atol: float
-):
+    gates: Sequence[cirq.Gate], intended_effect: np.ndarray, atol: float
+) -> None:
     actual_effect = cirq.dot(*[cirq.unitary(g) for g in reversed(gates)])
     cirq.testing.assert_allclose_up_to_global_phase(actual_effect, intended_effect, atol=atol)
 
 
-def test_is_negligible_turn():
+def test_is_negligible_turn() -> None:
     assert cirq.is_negligible_turn(0, 1e-5)
     assert cirq.is_negligible_turn(1e-6, 1e-5)
     assert cirq.is_negligible_turn(1, 1e-5)
@@ -57,37 +57,37 @@ def test_is_negligible_turn():
     assert not cirq.is_negligible_turn(sympy.Symbol('a') * 0 + 1.5 - 1e-6, 1e-5)
 
 
-def test_single_qubit_matrix_to_gates_known_x():
+def test_single_qubit_matrix_to_gates_known_x() -> None:
     actual = cirq.single_qubit_matrix_to_gates(np.array([[0, 1], [1, 0]]), tolerance=0.01)
 
     assert cirq.approx_eq(actual, [cirq.X], atol=1e-9)
 
 
-def test_single_qubit_matrix_to_gates_known_y():
+def test_single_qubit_matrix_to_gates_known_y() -> None:
     actual = cirq.single_qubit_matrix_to_gates(np.array([[0, -1j], [1j, 0]]), tolerance=0.01)
 
     assert cirq.approx_eq(actual, [cirq.Y], atol=1e-9)
 
 
-def test_single_qubit_matrix_to_gates_known_z():
+def test_single_qubit_matrix_to_gates_known_z() -> None:
     actual = cirq.single_qubit_matrix_to_gates(np.array([[1, 0], [0, -1]]), tolerance=0.01)
 
     assert cirq.approx_eq(actual, [cirq.Z], atol=1e-9)
 
 
-def test_single_qubit_matrix_to_gates_known_s():
+def test_single_qubit_matrix_to_gates_known_s() -> None:
     actual = cirq.single_qubit_matrix_to_gates(np.array([[1, 0], [0, 1j]]), tolerance=0.01)
 
     assert cirq.approx_eq(actual, [cirq.Z**0.5], atol=1e-9)
 
 
-def test_known_s_dag():
+def test_known_s_dag() -> None:
     actual = cirq.single_qubit_matrix_to_gates(np.array([[1, 0], [0, -1j]]), tolerance=0.01)
 
     assert cirq.approx_eq(actual, [cirq.Z**-0.5], atol=1e-9)
 
 
-def test_known_h():
+def test_known_h() -> None:
     actual = cirq.single_qubit_matrix_to_gates(
         np.array([[1, 1], [1, -1]]) * np.sqrt(0.5), tolerance=0.001
     )
@@ -109,7 +109,7 @@ def test_known_h():
     ]
     + [cirq.testing.random_unitary(2) for _ in range(10)],
 )
-def test_single_qubit_matrix_to_gates_cases(intended_effect):
+def test_single_qubit_matrix_to_gates_cases(intended_effect) -> None:
     for atol in [1e-1, 1e-8]:
         gates = cirq.single_qubit_matrix_to_gates(intended_effect, tolerance=atol / 10)
         assert len(gates) <= 3
@@ -120,7 +120,7 @@ def test_single_qubit_matrix_to_gates_cases(intended_effect):
 @pytest.mark.parametrize(
     'pre_turns,post_turns', [(random.random(), random.random()) for _ in range(10)]
 )
-def test_single_qubit_matrix_to_gates_fuzz_half_turns_merge_z_gates(pre_turns, post_turns):
+def test_single_qubit_matrix_to_gates_fuzz_half_turns_merge_z_gates(pre_turns, post_turns) -> None:
     intended_effect = cirq.dot(
         cirq.unitary(cirq.Z ** (2 * pre_turns)),
         cirq.unitary(cirq.X),
@@ -133,7 +133,7 @@ def test_single_qubit_matrix_to_gates_fuzz_half_turns_merge_z_gates(pre_turns, p
     assert_gates_implement_unitary(gates, intended_effect, atol=1e-6)
 
 
-def test_single_qubit_matrix_to_gates_tolerance_z():
+def test_single_qubit_matrix_to_gates_tolerance_z() -> None:
     z = np.diag([1, np.exp(1j * 0.01)])
 
     optimized_away = cirq.single_qubit_matrix_to_gates(z, tolerance=0.1)
@@ -143,7 +143,7 @@ def test_single_qubit_matrix_to_gates_tolerance_z():
     assert len(kept) == 1
 
 
-def test_single_qubit_matrix_to_gates_tolerance_xy():
+def test_single_qubit_matrix_to_gates_tolerance_xy() -> None:
     c, s = np.cos(0.01), np.sin(0.01)
     xy = np.array([[c, -s], [s, c]])
 
@@ -154,7 +154,7 @@ def test_single_qubit_matrix_to_gates_tolerance_xy():
     assert len(kept) == 1
 
 
-def test_single_qubit_matrix_to_gates_tolerance_half_turn_phasing():
+def test_single_qubit_matrix_to_gates_tolerance_half_turn_phasing() -> None:
     a = np.pi / 2 + 0.01
     c, s = np.cos(a), np.sin(a)
     nearly_x = np.array([[c, -s], [s, c]])
@@ -189,13 +189,13 @@ def _random_unitary_with_close_eigenvalues():
     ]
     + [cirq.testing.random_unitary(2) for _ in range(10)],
 )
-def test_single_qubit_op_to_framed_phase_form_equivalent_on_known_and_random(mat):
+def test_single_qubit_op_to_framed_phase_form_equivalent_on_known_and_random(mat) -> None:
     u, t, g = cirq.single_qubit_op_to_framed_phase_form(mat)
     z = np.diag([g, g * t])
     assert np.allclose(mat, np.conj(u.T).dot(z).dot(u))
 
 
-def test_single_qubit_matrix_to_phased_x_z_known():
+def test_single_qubit_matrix_to_phased_x_z_known() -> None:
     actual = cirq.single_qubit_matrix_to_phased_x_z(np.array([[0, 1], [1, 0]]), atol=0.01)
     assert cirq.approx_eq(actual, [cirq.PhasedXPowGate(phase_exponent=1.0)], atol=1e-9)
 
@@ -223,7 +223,7 @@ def test_single_qubit_matrix_to_phased_x_z_known():
     'intended_effect',
     [np.array([[0, 1j], [1, 0]])] + [cirq.testing.random_unitary(2) for _ in range(10)],
 )
-def test_single_qubit_matrix_to_phased_x_z_cases(intended_effect):
+def test_single_qubit_matrix_to_phased_x_z_cases(intended_effect) -> None:
     gates = cirq.single_qubit_matrix_to_phased_x_z(intended_effect, atol=1e-6)
     assert len(gates) <= 2
     assert_gates_implement_unitary(gates, intended_effect, atol=1e-5)
@@ -232,7 +232,9 @@ def test_single_qubit_matrix_to_phased_x_z_cases(intended_effect):
 @pytest.mark.parametrize(
     'pre_turns,post_turns', [(random.random(), random.random()) for _ in range(10)]
 )
-def test_single_qubit_matrix_to_phased_x_z_fuzz_half_turns_always_one_gate(pre_turns, post_turns):
+def test_single_qubit_matrix_to_phased_x_z_fuzz_half_turns_always_one_gate(
+    pre_turns, post_turns
+) -> None:
     atol = 1e-6
     aggr_atol = atol * 10.0
 
@@ -248,7 +250,7 @@ def test_single_qubit_matrix_to_phased_x_z_fuzz_half_turns_always_one_gate(pre_t
     assert_gates_implement_unitary(gates, intended_effect, atol=aggr_atol)
 
 
-def test_single_qubit_matrix_to_phased_x_z_tolerance_z():
+def test_single_qubit_matrix_to_phased_x_z_tolerance_z() -> None:
     z = np.diag([1, np.exp(1j * 0.01)])
 
     optimized_away = cirq.single_qubit_matrix_to_phased_x_z(z, atol=0.1)
@@ -258,7 +260,7 @@ def test_single_qubit_matrix_to_phased_x_z_tolerance_z():
     assert len(kept) == 1
 
 
-def test_single_qubit_matrix_to_phased_x_z_tolerance_xy():
+def test_single_qubit_matrix_to_phased_x_z_tolerance_xy() -> None:
     c, s = np.cos(0.01), np.sin(0.01)
     xy = np.array([[c, -s], [s, c]])
 
@@ -269,7 +271,7 @@ def test_single_qubit_matrix_to_phased_x_z_tolerance_xy():
     assert len(kept) == 1
 
 
-def test_single_qubit_matrix_to_phased_x_z_tolerance_half_turn_phasing():
+def test_single_qubit_matrix_to_phased_x_z_tolerance_half_turn_phasing() -> None:
     a = np.pi / 2 + 0.01
     c, s = np.cos(a), np.sin(a)
     nearly_x = np.array([[c, -s], [s, c]])
@@ -297,15 +299,16 @@ def test_single_qubit_matrix_to_phased_x_z_tolerance_half_turn_phasing():
         *[cirq.testing.random_unitary(2) for _ in range(10)],
     ],
 )
-def test_single_qubit_matrix_to_phxz_cases(intended_effect):
+def test_single_qubit_matrix_to_phxz_cases(intended_effect) -> None:
     gate = cirq.single_qubit_matrix_to_phxz(intended_effect, atol=1e-6)
+    assert gate is not None
     assert_gates_implement_unitary([gate], intended_effect, atol=1e-5)
 
 
 @pytest.mark.parametrize(
     'pre_turns,post_turns', [(random.random(), random.random()) for _ in range(10)]
 )
-def test_single_qubit_matrix_to_phxz_fuzz_half_turns_always_one_gate(pre_turns, post_turns):
+def test_single_qubit_matrix_to_phxz_fuzz_half_turns_always_one_gate(pre_turns, post_turns) -> None:
     atol = 1e-6
     aggr_atol = atol * 10.0
 
@@ -317,11 +320,12 @@ def test_single_qubit_matrix_to_phxz_fuzz_half_turns_always_one_gate(pre_turns,
 
     gate = cirq.single_qubit_matrix_to_phxz(intended_effect, atol=atol)
 
+    assert gate is not None
     assert gate.z_exponent == 0
     assert_gates_implement_unitary([gate], intended_effect, atol=aggr_atol)
 
 
-def test_single_qubit_matrix_to_phxz_tolerance_z():
+def test_single_qubit_matrix_to_phxz_tolerance_z() -> None:
     z = np.diag([1, np.exp(1j * 0.01)])
 
     optimized_away = cirq.single_qubit_matrix_to_phxz(z, atol=0.1)
@@ -331,7 +335,7 @@ def test_single_qubit_matrix_to_phxz_tolerance_z():
     assert kept is not None
 
 
-def test_single_qubit_matrix_to_phxz_tolerance_xy():
+def test_single_qubit_matrix_to_phxz_tolerance_xy() -> None:
     c, s = np.cos(0.01), np.sin(0.01)
     xy = np.array([[c, -s], [s, c]])
 
@@ -342,7 +346,7 @@ def test_single_qubit_matrix_to_phxz_tolerance_xy():
     assert kept is not None
 
 
-def test_single_qubit_matrix_to_phxz_tolerance_half_turn_phasing():
+def test_single_qubit_matrix_to_phxz_tolerance_half_turn_phasing() -> None:
     a = np.pi / 2 + 0.01
     c, s = np.cos(a), np.sin(a)
     nearly_x = np.array([[c, -s], [s, c]])
@@ -351,7 +355,9 @@ def test_single_qubit_matrix_to_phxz_tolerance_half_turn_phasing():
     phased_nearly_x = z1.dot(nearly_x).dot(z2)
 
     optimized_away = cirq.single_qubit_matrix_to_phxz(phased_nearly_x, atol=0.1)
+    assert optimized_away is not None
     assert optimized_away.z_exponent == 0
 
     kept = cirq.single_qubit_matrix_to_phxz(phased_nearly_x, atol=0.0001)
+    assert kept is not None
     assert kept.z_exponent != 0

cirq/transformers/analytical_decompositions/single_to_two_qubit_isometry_test.py

@@ -43,7 +43,7 @@ INVALID_INITIAL_STATES = [
 @pytest.mark.parametrize('allow_partial_czs', [True, False])
 def test_two_qubit_matrix_to_cz_isometry(
     initial_state, is_valid, unitary_matrix, allow_partial_czs
-):
+) -> None:
     a, b, c = cirq.LineQubit.range(3)
     decomposed_ops = cirq.two_qubit_matrix_to_cz_isometry(
         a, b, unitary_matrix, allow_partial_czs=allow_partial_czs

cirq/transformers/analytical_decompositions/two_qubit_state_preparation_test.py

@@ -17,6 +17,7 @@
 from __future__ import annotations
 
 import copy
+from typing import Iterator
 
 import numpy as np
 import pytest
@@ -24,11 +25,11 @@ import pytest
 import cirq
 
 
-def random_state(seed: float):
+def random_state(seed: float) -> np.ndarray:
     return cirq.testing.random_superposition(4, random_state=seed)
 
 
-def states_with_phases(st: np.ndarray):
+def states_with_phases(st: np.ndarray) -> Iterator[np.ndarray]:
     """Returns several states similar to st with modified global phases."""
     st = np.array(st, dtype="complex64")
     yield st
@@ -61,10 +62,10 @@ STATES_TO_PREPARE = [
 
 
 @pytest.mark.parametrize("state", STATES_TO_PREPARE)
-def test_prepare_two_qubit_state_using_cz(state):
+def test_prepare_two_qubit_state_using_cz(state) -> None:
     state = cirq.to_valid_state_vector(state, num_qubits=2)
-    q = cirq.LineQubit.range(2)
-    circuit = cirq.Circuit(cirq.prepare_two_qubit_state_using_cz(*q, state))
+    q0, q1 = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit(cirq.prepare_two_qubit_state_using_cz(q0, q1, state))
     ops_cz = [*circuit.findall_operations(lambda op: op.gate == cirq.CZ)]
     ops_2q = [*circuit.findall_operations(lambda op: cirq.num_qubits(op) > 1)]
     assert ops_cz == ops_2q
@@ -76,11 +77,11 @@ def test_prepare_two_qubit_state_using_cz(state):
 
 @pytest.mark.parametrize("state", STATES_TO_PREPARE)
 @pytest.mark.parametrize("use_iswap_inv", [True, False])
-def test_prepare_two_qubit_state_using_iswap(state, use_iswap_inv):
+def test_prepare_two_qubit_state_using_iswap(state, use_iswap_inv) -> None:
     state = cirq.to_valid_state_vector(state, num_qubits=2)
-    q = cirq.LineQubit.range(2)
+    q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
-        cirq.prepare_two_qubit_state_using_iswap(*q, state, use_iswap_inv=use_iswap_inv)
+        cirq.prepare_two_qubit_state_using_iswap(q0, q1, state, use_iswap_inv=use_iswap_inv)
     )
     iswap_gate = cirq.ISWAP_INV if use_iswap_inv else cirq.ISWAP
     ops_iswap = [*circuit.findall_operations(lambda op: op.gate == iswap_gate)]
@@ -94,12 +95,12 @@ def test_prepare_two_qubit_state_using_iswap(state, use_iswap_inv):
 
 @pytest.mark.parametrize("state", STATES_TO_PREPARE)
 @pytest.mark.parametrize("use_sqrt_iswap_inv", [True, False])
-def test_prepare_two_qubit_state_using_sqrt_iswap(state, use_sqrt_iswap_inv):
+def test_prepare_two_qubit_state_using_sqrt_iswap(state, use_sqrt_iswap_inv) -> None:
     state = cirq.to_valid_state_vector(state, num_qubits=2)
-    q = cirq.LineQubit.range(2)
+    q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.prepare_two_qubit_state_using_sqrt_iswap(
-            *q, state, use_sqrt_iswap_inv=use_sqrt_iswap_inv
+            q0, q1, state, use_sqrt_iswap_inv=use_sqrt_iswap_inv
         )
     )
     sqrt_iswap_gate = cirq.SQRT_ISWAP_INV if use_sqrt_iswap_inv else cirq.SQRT_ISWAP

cirq/transformers/analytical_decompositions/two_qubit_to_cz.py

@@ -181,7 +181,9 @@ def _xx_yy_zz_interaction_via_full_czs(q0: cirq.Qid, q1: cirq.Qid, x: float, y:
     yield ops.H(q1)
 
 
-def cleanup_operations(operations: Sequence[ops.Operation], atol: float = 1e-8):
+def cleanup_operations(
+    operations: Sequence[ops.Operation], atol: float = 1e-8
+) -> list[ops.Operation]:
     operations = _merge_single_qubit_gates(operations, atol=atol)
     circuit = circuits.Circuit(operations)
     circuit = eject_phased_paulis(circuit)

cirq/transformers/analytical_decompositions/two_qubit_to_cz_test.py

@@ -95,7 +95,7 @@ def _random_double_full_cz_effect():
     )
 
 
-def assert_cz_depth_below(operations, threshold, must_be_full):
+def assert_cz_depth_below(operations, threshold, must_be_full) -> None:
     total_cz = 0
 
     for op in operations:
@@ -110,7 +110,7 @@ def assert_cz_depth_below(operations, threshold, must_be_full):
     assert total_cz <= threshold
 
 
-def assert_ops_implement_unitary(q0, q1, operations, intended_effect, atol=0.01):
+def assert_ops_implement_unitary(q0, q1, operations, intended_effect, atol=0.01) -> None:
     actual_effect = _operations_to_matrix(operations, (q0, q1))
     assert cirq.allclose_up_to_global_phase(actual_effect, intended_effect, atol=atol)
 
@@ -273,7 +273,7 @@ def test_decompose_to_diagonal_and_circuit(v) -> None:
 )
 def test_decompose_to_diagonal_and_circuit_returns_circuit_with_expected_number_of_czs(
     mat, num_czs
-):
+) -> None:
     b, c = cirq.LineQubit.range(2)
     _, ops = two_qubit_matrix_to_diagonal_and_cz_operations(b, c, mat, atol=1e-8)
     circuit = cirq.Circuit(ops)

cirq/transformers/analytical_decompositions/two_qubit_to_ms_test.py

@@ -60,12 +60,12 @@ def _random_double_MS_effect():
     )
 
 
-def assert_ops_implement_unitary(q0, q1, operations, intended_effect, atol=0.01):
+def assert_ops_implement_unitary(q0, q1, operations, intended_effect, atol=0.01) -> None:
     actual_effect = _operations_to_matrix(operations, (q0, q1))
     assert cirq.allclose_up_to_global_phase(actual_effect, intended_effect, atol=atol)
 
 
-def assert_ms_depth_below(operations, threshold):
+def assert_ms_depth_below(operations, threshold) -> None:
     total_ms = 0
 
     for op in operations: