cirq-core 1.7.0.dev20250825174419__py3-none-any.whl → 1.7.0.dev20251203004401__py3-none-any.whl

cirq/transformers/analytical_decompositions/single_qubit_decompositions_test.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import random
-from typing import Sequence
+from collections.abc import Sequence
 
 import numpy as np
 import pytest
@@ -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/three_qubit_decomposition.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Sequence
+from collections.abc import Sequence
 
 import numpy as np
 import scipy.linalg

cirq/transformers/analytical_decompositions/two_qubit_state_preparation_test.py

@@ -17,6 +17,7 @@
 from __future__ import annotations
 
 import copy
+from collections.abc 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

@@ -16,7 +16,8 @@
 
 from __future__ import annotations
 
-from typing import cast, Iterable, Sequence, TYPE_CHECKING
+from collections.abc import Iterable, Sequence
+from typing import cast, TYPE_CHECKING
 
 import numpy as np
 
@@ -181,7 +182,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_fsim.py

@@ -16,7 +16,8 @@
 
 from __future__ import annotations
 
-from typing import Iterable, Iterator, Sequence, TYPE_CHECKING
+from collections.abc import Iterable, Iterator, Sequence
+from typing import TYPE_CHECKING
 
 import numpy as np
 

cirq/transformers/analytical_decompositions/two_qubit_to_ms.py

@@ -21,7 +21,8 @@ Gate compilation methods implemented here are following the paper below:
 
 from __future__ import annotations
 
-from typing import cast, Iterable, TYPE_CHECKING
+from collections.abc import Iterable
+from typing import cast, TYPE_CHECKING
 
 from cirq import linalg, ops, protocols
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions, two_qubit_to_cz

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:

cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap.py

@@ -22,7 +22,8 @@ References:
 
 from __future__ import annotations
 
-from typing import Sequence, TYPE_CHECKING
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
 
 import numpy as np
 import sympy

cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap_test.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import itertools
+from collections.abc import Iterator
 
 import numpy as np
 import pytest
@@ -23,11 +24,11 @@ import sympy
 import cirq
 
 
-def random_unitary(seed):
+def random_unitary(seed: cirq.RANDOM_STATE_OR_SEED_LIKE) -> np.ndarray:
     return cirq.testing.random_unitary(4, random_state=seed)
 
 
-def random_locals(x, y, z, seed=None):
+def random_locals(x: float, y: float, z: float, seed=None) -> np.ndarray:
     rng = np.random.RandomState(seed)
     a0 = cirq.testing.random_unitary(2, random_state=rng)
     a1 = cirq.testing.random_unitary(2, random_state=rng)
@@ -42,15 +43,14 @@ def random_locals(x, y, z, seed=None):
     )
 
 
-def perturbations_unitary(u, amount=1e-10):
+def perturbations_unitary(u: np.ndarray, amount=1e-10) -> Iterator[np.ndarray]:
     """Returns several unitaries in the neighborhood of u to test for numerical
     corner cases near critical values."""
     kak = cirq.kak_decomposition(u)
     yield u
     for i in range(3):
         for neg in (-1, 1):
-            perturb_xyz = list(kak.interaction_coefficients)
-            perturb_xyz[i] += neg * amount
+            perturb_xyz = tuple(c + neg * amount for c in kak.interaction_coefficients)
             yield cirq.unitary(
                 cirq.KakDecomposition(
                     global_phase=kak.global_phase,
@@ -61,11 +61,11 @@ def perturbations_unitary(u, amount=1e-10):
             )
 
 
-def perturbations_gate(gate, amount=1e-10):
+def perturbations_gate(gate: cirq.SupportsUnitary, amount=1e-10) -> Iterator[np.ndarray]:
     return perturbations_unitary(cirq.unitary(gate), amount)
 
 
-def perturbations_weyl(x, y, z, amount=1e-10):
+def perturbations_weyl(x: float, y: float, z: float, amount: float = 1e-10) -> Iterator[np.ndarray]:
     return perturbations_gate(cirq.KakDecomposition(interaction_coefficients=(x, y, z)), amount)
 
 
@@ -211,7 +211,7 @@ def assert_valid_decomp(
     atol=1e-6,
     rtol=0,
     qubit_order=cirq.LineQubit.range(2),
-):
+) -> None:
     # Check expected gates
     for op in operations:
         if len(op.qubits) == 0 and isinstance(op.gate, cirq.GlobalPhaseGate):
@@ -242,7 +242,7 @@ def assert_valid_decomp(
         )
 
 
-def assert_specific_sqrt_iswap_count(operations, count):
+def assert_specific_sqrt_iswap_count(operations, count) -> None:
     actual = sum(len(op.qubits) == 2 for op in operations)
     assert actual == count, f'Incorrect sqrt-iSWAP count.  Expected {count} but got {actual}.'
 
@@ -255,7 +255,7 @@ def assert_specific_sqrt_iswap_count(operations, count):
         cirq.CZPowGate(exponent=sympy.Symbol('t')),
     ],
 )
-def test_two_qubit_gates_with_symbols(gate: cirq.Gate):
+def test_two_qubit_gates_with_symbols(gate: cirq.Gate) -> None:
     op = gate(*cirq.LineQubit.range(2))
     c_new_sqrt_iswap = cirq.Circuit(
         cirq.parameterized_2q_op_to_sqrt_iswap_operations(op)  # type: ignore
@@ -279,12 +279,14 @@ def test_two_qubit_gates_with_symbols(gate: cirq.Gate):
         )
 
 
-def test_fsim_gate_with_symbols():
+def test_fsim_gate_with_symbols() -> None:
     theta, phi = sympy.symbols(['theta', 'phi'])
     op = cirq.FSimGate(theta=theta, phi=phi).on(*cirq.LineQubit.range(2))
-    c_new_sqrt_iswap = cirq.Circuit(cirq.parameterized_2q_op_to_sqrt_iswap_operations(op))
+    c_new_sqrt_iswap = cirq.Circuit(
+        cirq.parameterized_2q_op_to_sqrt_iswap_operations(op)  # type: ignore[arg-type]
+    )
     c_new_sqrt_iswap_inv = cirq.Circuit(
-        cirq.parameterized_2q_op_to_sqrt_iswap_operations(op, use_sqrt_iswap_inv=True)
+        cirq.parameterized_2q_op_to_sqrt_iswap_operations(op, use_sqrt_iswap_inv=True)  # type: ignore[arg-type]
     )
     for theta_val in np.linspace(0, 2 * np.pi, 4):
         for phi_val in np.linspace(0, 2 * np.pi, 6):
@@ -307,7 +309,7 @@ def test_fsim_gate_with_symbols():
 
 
 @pytest.mark.parametrize('cnt', [-1, 4, 10])
-def test_invalid_required_sqrt_iswap_count(cnt):
+def test_invalid_required_sqrt_iswap_count(cnt) -> None:
     u = TWO_SQRT_ISWAP_UNITARIES[0]
     q0, q1 = cirq.LineQubit.range(2)
     with pytest.raises(ValueError, match='required_sqrt_iswap_count'):
@@ -315,7 +317,7 @@ def test_invalid_required_sqrt_iswap_count(cnt):
 
 
 @pytest.mark.parametrize('u', ZERO_UNITARIES)
-def test_decomp0(u):
+def test_decomp0(u) -> None:
     # Decompose unitaries into zero sqrt-iSWAP gates
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, required_sqrt_iswap_count=0)
@@ -326,7 +328,7 @@ def test_decomp0(u):
 @pytest.mark.parametrize(
     'u', ONE_SQRT_ISWAP_UNITARIES + TWO_SQRT_ISWAP_UNITARIES + THREE_SQRT_ISWAP_UNITARIES
 )
-def test_decomp0_invalid(u):
+def test_decomp0_invalid(u) -> None:
     # Attempt to decompose other unitaries into zero SQRT_ISWAP gates
     q0, q1 = cirq.LineQubit.range(2)
     with pytest.raises(ValueError, match='cannot be decomposed into exactly 0 sqrt-iSWAP gates'):
@@ -334,7 +336,7 @@ def test_decomp0_invalid(u):
 
 
 @pytest.mark.parametrize('u', ONE_SQRT_ISWAP_UNITARIES)
-def test_decomp1(u):
+def test_decomp1(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, required_sqrt_iswap_count=1)
     assert_valid_decomp(u, ops)
@@ -344,14 +346,14 @@ def test_decomp1(u):
 @pytest.mark.parametrize(
     'u', ZERO_UNITARIES + TWO_SQRT_ISWAP_UNITARIES + THREE_SQRT_ISWAP_UNITARIES
 )
-def test_decomp1_invalid(u):
+def test_decomp1_invalid(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     with pytest.raises(ValueError, match='cannot be decomposed into exactly 1 sqrt-iSWAP gates'):
         cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, required_sqrt_iswap_count=1)
 
 
 @pytest.mark.parametrize('u', ZERO_UNITARIES + ONE_SQRT_ISWAP_UNITARIES + TWO_SQRT_ISWAP_UNITARIES)
-def test_decomp2(u):
+def test_decomp2(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, required_sqrt_iswap_count=2)
     assert_valid_decomp(u, ops)
@@ -359,7 +361,7 @@ def test_decomp2(u):
 
 
 @pytest.mark.parametrize('u', THREE_SQRT_ISWAP_UNITARIES)
-def test_decomp2_invalid(u):
+def test_decomp2_invalid(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     with pytest.raises(ValueError, match='cannot be decomposed into exactly 2 sqrt-iSWAP gates'):
         cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, required_sqrt_iswap_count=2)
@@ -372,14 +374,14 @@ def test_decomp2_invalid(u):
     + TWO_SQRT_ISWAP_UNITARIES
     + THREE_SQRT_ISWAP_UNITARIES,
 )
-def test_decomp3(u):
+def test_decomp3(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, required_sqrt_iswap_count=3)
     assert_valid_decomp(u, ops)
     assert_specific_sqrt_iswap_count(ops, 3)
 
 
-def test_decomp3_invalid():
+def test_decomp3_invalid() -> None:
     # All two-qubit gates can be synthesized with three SQRT_ISWAP gates
     u = cirq.unitary(cirq.X**0.2)  # Pass an invalid size unitary
     q0, q1 = cirq.LineQubit.range(2)
@@ -388,7 +390,7 @@ def test_decomp3_invalid():
 
 
 @pytest.mark.parametrize('u', TWO_SQRT_ISWAP_UNITARIES[:1])
-def test_qubit_order(u):
+def test_qubit_order(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q1, q0, u, required_sqrt_iswap_count=2)
     assert_valid_decomp(u, ops, qubit_order=(q1, q0))
@@ -396,7 +398,7 @@ def test_qubit_order(u):
 
 
 @pytest.mark.parametrize('u', ZERO_UNITARIES)
-def test_decomp_optimal0(u):
+def test_decomp_optimal0(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u)
     assert_valid_decomp(u, ops)
@@ -404,7 +406,7 @@ def test_decomp_optimal0(u):
 
 
 @pytest.mark.parametrize('u', ONE_SQRT_ISWAP_UNITARIES)
-def test_decomp_optimal1(u):
+def test_decomp_optimal1(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u)
     assert_valid_decomp(u, ops)
@@ -412,7 +414,7 @@ def test_decomp_optimal1(u):
 
 
 @pytest.mark.parametrize('u', TWO_SQRT_ISWAP_UNITARIES)
-def test_decomp_optimal2(u):
+def test_decomp_optimal2(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u)
     assert_valid_decomp(u, ops)
@@ -420,7 +422,7 @@ def test_decomp_optimal2(u):
 
 
 @pytest.mark.parametrize('u', THREE_SQRT_ISWAP_UNITARIES)
-def test_decomp_optimal3(u):
+def test_decomp_optimal3(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u)
     assert_valid_decomp(u, ops)
@@ -428,7 +430,7 @@ def test_decomp_optimal3(u):
 
 
 @pytest.mark.parametrize('u', ALL_REGION_UNITARIES)
-def test_all_weyl_regions(u):
+def test_all_weyl_regions(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, clean_operations=True)
     assert_valid_decomp(u, ops, single_qubit_gate_types=(cirq.PhasedXZGate,))
@@ -445,13 +447,13 @@ def test_all_weyl_regions(u):
         THREE_SQRT_ISWAP_UNITARIES[0],
     ],
 )
-def test_decomp_sqrt_iswap_inv(u):
+def test_decomp_sqrt_iswap_inv(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, use_sqrt_iswap_inv=True)
     assert_valid_decomp(u, ops, two_qubit_gate=cirq.SQRT_ISWAP_INV)
 
 
-def test_valid_check_raises():
+def test_valid_check_raises() -> None:
     q0 = cirq.LineQubit(0)
     with pytest.raises(AssertionError, match='Unitaries are completely different'):
         assert_valid_decomp(np.eye(4), [cirq.X(q0)], single_qubit_gate_types=(cirq.XPowGate,))