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

cirq/transformers/_connected_component_test.py

@@ -0,0 +1,200 @@
+# Copyright 2025 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import pytest
+
+import cirq
+from cirq.transformers._connected_component import (
+    ComponentSet,
+    ComponentWithCircuitOpSet,
+    ComponentWithOpsSet,
+)
+
+
+def _always_mergeable(_: cirq.Operation) -> bool:
+    return True
+
+
+def _never_mergeable(_: cirq.Operation) -> bool:
+    return False
+
+
+def _always_can_merge(_ops1: list[cirq.Operation], _ops2: list[cirq.Operation]) -> bool:
+    return True
+
+
+def _never_can_merge(_ops1: list[cirq.Operation], _ops2: list[cirq.Operation]) -> bool:
+    return False
+
+
+def _merge_as_first_operation(op1: cirq.Operation, _op2: cirq.Operation) -> cirq.Operation:
+    return op1
+
+
+def _merge_never_successful(op1: cirq.Operation, _op2: cirq.Operation) -> None:
+    return None
+
+
+def test_find_returns_itself_for_singleton():
+    cset = ComponentSet(_always_mergeable)
+
+    q = cirq.NamedQubit('x')
+    c = cset.new_component(op=cirq.X(q), moment_id=0)
+    assert cset.find(c) is c
+
+
+def test_merge_components():
+    cset = ComponentSet(_always_mergeable)
+
+    q = cirq.NamedQubit('x')
+    c = [cset.new_component(op=cirq.X(q), moment_id=i) for i in range(5)]
+    cset.merge(c[1], c[0])
+    cset.merge(c[2], c[1])
+    cset.merge(c[4], c[3])
+    cset.merge(c[3], c[0])
+
+    for i in range(5):
+        assert cset.find(c[i]) is cset.find(c[0])
+
+
+def test_merge_same_component():
+    cset = ComponentSet(_always_mergeable)
+
+    q = cirq.NamedQubit('x')
+    c = [cset.new_component(op=cirq.X(q), moment_id=i) for i in range(3)]
+    cset.merge(c[1], c[0])
+    cset.merge(c[2], c[1])
+
+    root = cset.find(c[0])
+
+    assert cset.merge(c[0], c[2]) is root
+
+
+def test_merge_returns_None_if_one_component_is_not_mergeable():
+    cset = ComponentSet(_always_mergeable)
+
+    q = cirq.NamedQubit('x')
+    c0 = cset.new_component(op=cirq.X(q), moment_id=0, is_mergeable=True)
+    c1 = cset.new_component(op=cirq.X(q), moment_id=1, is_mergeable=False)
+    assert cset.merge(c0, c1) is None
+
+
+def test_cset_merge_returns_None_if_is_mergeable_is_false():
+    q = cirq.NamedQubit('x')
+    cset = ComponentSet(is_mergeable=_never_mergeable)
+
+    c0 = cset.new_component(op=cirq.X(q), moment_id=0, is_mergeable=True)
+    c1 = cset.new_component(op=cirq.X(q), moment_id=1, is_mergeable=True)
+    assert cset.merge(c0, c1) is None
+
+
+@pytest.mark.parametrize("merge_left,expected_moment_id", [(True, 0), (False, 1)])
+def test_merge_qubits_with_merge_left(merge_left: bool, expected_moment_id: int) -> None:
+    cset = ComponentSet(_always_mergeable)
+
+    q0 = cirq.NamedQubit('x')
+    q1 = cirq.NamedQubit('y')
+    c0 = cset.new_component(op=cirq.X(q0), moment_id=0)
+    c1 = cset.new_component(op=cirq.X(q1), moment_id=1)
+    c2 = cset.new_component(op=cirq.X(q1), moment_id=2)
+    cset.merge(c1, c2)
+    cset.merge(c0, c1, merge_left=merge_left)
+    assert cset.find(c1).qubits == frozenset([q0, q1])
+    assert cset.find(c1).moment_id == expected_moment_id
+
+
+def test_component_with_ops_merge():
+    cset = ComponentWithOpsSet(_always_mergeable, _always_can_merge)
+
+    q = cirq.LineQubit.range(3)
+    ops = [cirq.X(q[i]) for i in range(3)]
+    c = [cset.new_component(op=ops[i], moment_id=i) for i in range(3)]
+    cset.merge(c[0], c[1])
+    cset.merge(c[1], c[2])
+    assert cset.find(c[0]).ops == ops
+    # check merge of indirectly merged components does not make a difference
+    assert cset.merge(c[0], c[2]).ops == ops
+
+
+def test_component_with_ops_merge_when_merge_fails():
+    cset = ComponentWithOpsSet(_always_mergeable, _never_can_merge)
+
+    q = cirq.LineQubit.range(3)
+    ops = [cirq.X(q[i]) for i in range(3)]
+    c = [cset.new_component(op=ops[i], moment_id=i) for i in range(3)]
+
+    cset.merge(c[0], c[1])
+    cset.merge(c[1], c[2])
+    # No merge happened
+    for i in range(3):
+        assert cset.find(c[i]) is c[i]
+
+
+def test_component_with_ops_merge_when_is_mergeable_is_false():
+    cset = ComponentWithOpsSet(_never_mergeable, _always_can_merge)
+
+    q = cirq.LineQubit.range(3)
+    ops = [cirq.X(q[i]) for i in range(3)]
+    c = [cset.new_component(op=ops[i], moment_id=i) for i in range(3)]
+
+    cset.merge(c[0], c[1])
+    cset.merge(c[1], c[2])
+    # No merge happened
+    for i in range(3):
+        assert cset.find(c[i]) is c[i]
+
+
+def test_component_with_circuit_op_merge():
+    cset = ComponentWithCircuitOpSet(_always_mergeable, _merge_as_first_operation)
+
+    q = cirq.LineQubit.range(3)
+    ops = [cirq.X(q[i]) for i in range(3)]
+    c = [cset.new_component(op=ops[i], moment_id=i) for i in range(3)]
+
+    cset.merge(c[0], c[1])
+    cset.merge(c[1], c[2])
+    for i in range(3):
+        assert cset.find(c[i]).circuit_op == ops[0]
+    # check merge of indirectly merged components does not make a difference
+    assert cset.merge(c[0], c[2]) is cset.find(c[1])
+
+
+def test_component_with_circuit_op_merge_func_is_none():
+    cset = ComponentWithCircuitOpSet(_always_mergeable, _merge_never_successful)
+
+    q = cirq.LineQubit.range(3)
+    ops = [cirq.X(q[i]) for i in range(3)]
+    c = [cset.new_component(op=ops[i], moment_id=i) for i in range(3)]
+
+    cset.merge(c[0], c[1])
+    cset.merge(c[1], c[2])
+    # No merge happened
+    for i in range(3):
+        assert cset.find(c[i]) is c[i]
+
+
+def test_component_with_circuit_op_merge_when_is_mergeable_is_false():
+    cset = ComponentWithCircuitOpSet(_never_mergeable, _merge_as_first_operation)
+
+    q = cirq.LineQubit.range(3)
+    ops = [cirq.X(q[i]) for i in range(3)]
+    c = [cset.new_component(op=ops[i], moment_id=i) for i in range(3)]
+
+    cset.merge(c[0], c[1])
+    cset.merge(c[1], c[2])
+    # No merge happened
+    for i in range(3):
+        assert cset.find(c[i]) is c[i]

cirq/transformers/align_test.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import cirq
 
 
-def test_align_basic_no_context():
+def test_align_basic_no_context() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     c = cirq.Circuit(
@@ -45,7 +45,7 @@ def test_align_basic_no_context():
     )
 
 
-def test_align_left_no_compile_context():
+def test_align_left_no_compile_context() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     cirq.testing.assert_same_circuits(
@@ -59,7 +59,7 @@ def test_align_left_no_compile_context():
                     cirq.measure(*[q1, q2], key='a'),
                 ]
             ),
-            context=cirq.TransformerContext(tags_to_ignore=["nocompile"]),
+            context=cirq.TransformerContext(tags_to_ignore=("nocompile",)),
         ),
         cirq.Circuit(
             [
@@ -73,7 +73,7 @@ def test_align_left_no_compile_context():
     )
 
 
-def test_align_left_deep():
+def test_align_left_deep() -> None:
     q1, q2 = cirq.LineQubit.range(2)
     c_nested = cirq.FrozenCircuit(
         [
@@ -104,11 +104,11 @@ def test_align_left_deep():
         c_nested_aligned,
         cirq.CircuitOperation(c_nested_aligned).repeat(5).with_tags("preserve_tag"),
     )
-    context = cirq.TransformerContext(tags_to_ignore=["nocompile"], deep=True)
+    context = cirq.TransformerContext(tags_to_ignore=("nocompile",), deep=True)
     cirq.testing.assert_same_circuits(cirq.align_left(c_orig, context=context), c_expected)
 
 
-def test_align_left_subset_of_operations():
+def test_align_left_subset_of_operations() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     tag = "op_to_align"
@@ -134,7 +134,7 @@ def test_align_left_subset_of_operations():
         cirq.toggle_tags(
             cirq.align_left(
                 cirq.toggle_tags(c_orig, [tag]),
-                context=cirq.TransformerContext(tags_to_ignore=[tag]),
+                context=cirq.TransformerContext(tags_to_ignore=(tag,)),
             ),
             [tag],
         ),
@@ -142,7 +142,7 @@ def test_align_left_subset_of_operations():
     )
 
 
-def test_align_right_no_compile_context():
+def test_align_right_no_compile_context() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     cirq.testing.assert_same_circuits(
@@ -156,7 +156,7 @@ def test_align_right_no_compile_context():
                     cirq.measure(*[q1, q2], key='a'),
                 ]
             ),
-            context=cirq.TransformerContext(tags_to_ignore=["nocompile"]),
+            context=cirq.TransformerContext(tags_to_ignore=("nocompile",)),
         ),
         cirq.Circuit(
             [
@@ -170,7 +170,7 @@ def test_align_right_no_compile_context():
     )
 
 
-def test_align_right_deep():
+def test_align_right_deep() -> None:
     q1, q2 = cirq.LineQubit.range(2)
     c_nested = cirq.FrozenCircuit(
         cirq.Moment([cirq.X(q1)]),
@@ -199,11 +199,11 @@ def test_align_right_deep():
         c_nested_aligned,
         cirq.CircuitOperation(c_nested_aligned).repeat(5).with_tags("preserve_tag"),
     )
-    context = cirq.TransformerContext(tags_to_ignore=["nocompile"], deep=True)
+    context = cirq.TransformerContext(tags_to_ignore=("nocompile",), deep=True)
     cirq.testing.assert_same_circuits(cirq.align_right(c_orig, context=context), c_expected)
 
 
-def test_classical_control():
+def test_classical_control() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.H(q0), cirq.measure(q0, key='m'), cirq.X(q1).with_classical_controls('m')
@@ -212,7 +212,7 @@ def test_classical_control():
     cirq.testing.assert_same_circuits(cirq.align_right(circuit), circuit)
 
 
-def test_measurement_and_classical_control_same_moment_preserve_order():
+def test_measurement_and_classical_control_same_moment_preserve_order() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     op_measure = cirq.measure(q0, key='m')

cirq/transformers/analytical_decompositions/clifford_decomposition.py

@@ -17,6 +17,7 @@
 from __future__ import annotations
 
 import functools
+from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -31,7 +32,7 @@ def _X(
     q: int,
     args: sim.CliffordTableauSimulationState,
     operations: list[ops.Operation],
-    qubits: list[cirq.Qid],
+    qubits: Sequence[cirq.Qid],
 ):
     protocols.act_on(ops.X, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.X(qubits[q]))
@@ -41,7 +42,7 @@ def _Z(
     q: int,
     args: sim.CliffordTableauSimulationState,
     operations: list[ops.Operation],
-    qubits: list[cirq.Qid],
+    qubits: Sequence[cirq.Qid],
 ):
     protocols.act_on(ops.Z, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.Z(qubits[q]))
@@ -51,7 +52,7 @@ def _Sdg(
     q: int,
     args: sim.CliffordTableauSimulationState,
     operations: list[ops.Operation],
-    qubits: list[cirq.Qid],
+    qubits: Sequence[cirq.Qid],
 ):
     # Apply the tableau with S^\{dagger}
     protocols.act_on(ops.S**-1, args, qubits=[qubits[q]], allow_decompose=False)
@@ -62,7 +63,7 @@ def _H(
     q: int,
     args: sim.CliffordTableauSimulationState,
     operations: list[ops.Operation],
-    qubits: list[cirq.Qid],
+    qubits: Sequence[cirq.Qid],
 ):
     protocols.act_on(ops.H, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.H(qubits[q]))
@@ -73,7 +74,7 @@ def _CNOT(
     q2: int,
     args: sim.CliffordTableauSimulationState,
     operations: list[ops.Operation],
-    qubits: list[cirq.Qid],
+    qubits: Sequence[cirq.Qid],
 ):
     protocols.act_on(ops.CNOT, args, qubits=[qubits[q1], qubits[q2]], allow_decompose=False)
     operations.append(ops.CNOT(qubits[q1], qubits[q2]))
@@ -84,14 +85,14 @@ def _SWAP(
     q2: int,
     args: sim.CliffordTableauSimulationState,
     operations: list[ops.Operation],
-    qubits: list[cirq.Qid],
+    qubits: Sequence[cirq.Qid],
 ):
     protocols.act_on(ops.SWAP, args, qubits=[qubits[q1], qubits[q2]], allow_decompose=False)
     operations.append(ops.SWAP(qubits[q1], qubits[q2]))
 
 
 def decompose_clifford_tableau_to_operations(
-    qubits: list[cirq.Qid], clifford_tableau: qis.CliffordTableau
+    qubits: Sequence[cirq.Qid], clifford_tableau: qis.CliffordTableau
 ) -> list[ops.Operation]:
     """Decompose an n-qubit Clifford Tableau into a list of one/two qubit operations.
 

cirq/transformers/analytical_decompositions/clifford_decomposition_test.py

@@ -21,14 +21,14 @@ import cirq
 from cirq.testing import assert_allclose_up_to_global_phase
 
 
-def test_misaligned_qubits():
+def test_misaligned_qubits() -> None:
     qubits = cirq.LineQubit.range(1)
     tableau = cirq.CliffordTableau(num_qubits=2)
     with pytest.raises(ValueError):
         cirq.decompose_clifford_tableau_to_operations(qubits, tableau)
 
 
-def test_clifford_decompose_one_qubit():
+def test_clifford_decompose_one_qubit() -> None:
     """Two random instance for one qubit decomposition."""
     qubits = cirq.LineQubit.range(1)
     args = cirq.CliffordTableauSimulationState(
@@ -63,7 +63,7 @@ def test_clifford_decompose_one_qubit():
     assert_allclose_up_to_global_phase(cirq.unitary(expect_circ), cirq.unitary(circ), atol=1e-7)
 
 
-def test_clifford_decompose_two_qubits():
+def test_clifford_decompose_two_qubits() -> None:
     """Two random instance for two qubits decomposition."""
     qubits = cirq.LineQubit.range(2)
     args = cirq.CliffordTableauSimulationState(
@@ -98,7 +98,7 @@ def test_clifford_decompose_two_qubits():
     assert_allclose_up_to_global_phase(cirq.unitary(expect_circ), cirq.unitary(circ), atol=1e-7)
 
 
-def test_clifford_decompose_by_unitary():
+def test_clifford_decompose_by_unitary() -> None:
     """Validate the decomposition of random Clifford Tableau by unitary matrix.
 
     Due to the exponential growth in dimension, it cannot validate very large number of qubits.
@@ -125,7 +125,7 @@ def test_clifford_decompose_by_unitary():
         assert_allclose_up_to_global_phase(cirq.unitary(expect_circ), cirq.unitary(circ), atol=1e-7)
 
 
-def test_clifford_decompose_by_reconstruction():
+def test_clifford_decompose_by_reconstruction() -> None:
     """Validate the decomposition of random Clifford Tableau by reconstruction.
 
     This approach can validate large number of qubits compared with the unitary one.

cirq/transformers/analytical_decompositions/controlled_gate_decomposition.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import itertools
+from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -114,7 +115,7 @@ def _ccnot_congruent(c0: cirq.Qid, c1: cirq.Qid, target: cirq.Qid) -> list[cirq.
 
 
 def decompose_multi_controlled_x(
-    controls: list[cirq.Qid], target: cirq.Qid, free_qubits: list[cirq.Qid]
+    controls: Sequence[cirq.Qid], target: cirq.Qid, free_qubits: Sequence[cirq.Qid]
 ) -> list[cirq.Operation]:
     """Implements action of multi-controlled Pauli X gate.
 
@@ -152,11 +153,11 @@ def decompose_multi_controlled_x(
     elif len(free_qubits) >= 1:
         # See [1], Lemma 7.3.
         m1 = n // 2
-        free1 = controls[m1:] + [target] + free_qubits[1:]
+        free1 = [*controls[m1:], target, *free_qubits[1:]]
         ctrl1 = controls[:m1]
         part1 = decompose_multi_controlled_x(ctrl1, free_qubits[0], free1)
-        free2 = controls[:m1] + free_qubits[1:]
-        ctrl2 = controls[m1:] + [free_qubits[0]]
+        free2 = [*controls[:m1], *free_qubits[1:]]
+        ctrl2 = [*controls[m1:], free_qubits[0]]
         part2 = decompose_multi_controlled_x(ctrl2, target, free2)
         return [*part1, *part2, *part1, *part2]
     else:
@@ -167,7 +168,7 @@ def decompose_multi_controlled_x(
 
 
 def _decompose_su(
-    matrix: np.ndarray, controls: list[cirq.Qid], target: cirq.Qid
+    matrix: np.ndarray, controls: Sequence[cirq.Qid], target: cirq.Qid
 ) -> list[cirq.Operation]:
     """Decomposes controlled special unitary gate into elementary gates.
 
@@ -193,9 +194,9 @@ def _decompose_su(
 def _decompose_recursive(
     matrix: np.ndarray,
     power: float,
-    controls: list[cirq.Qid],
+    controls: Sequence[cirq.Qid],
     target: cirq.Qid,
-    free_qubits: list[cirq.Qid],
+    free_qubits: Sequence[cirq.Qid],
 ) -> list[cirq.Operation]:
     """Decomposes controlled unitary gate into elementary gates.
 
@@ -205,20 +206,20 @@ def _decompose_recursive(
     if len(controls) == 1:
         return _decompose_single_ctrl(_unitary_power(matrix, power), controls[0], target)
 
-    cnots = decompose_multi_controlled_x(controls[:-1], controls[-1], free_qubits + [target])
+    cnots = decompose_multi_controlled_x(controls[:-1], controls[-1], [*free_qubits, target])
     return [
         *_decompose_single_ctrl(_unitary_power(matrix, 0.5 * power), controls[-1], target),
         *cnots,
         *_decompose_single_ctrl(_unitary_power(matrix, -0.5 * power), controls[-1], target),
         *cnots,
         *_decompose_recursive(
-            matrix, 0.5 * power, controls[:-1], target, [controls[-1]] + free_qubits
+            matrix, 0.5 * power, controls[:-1], target, [controls[-1], *free_qubits]
         ),
     ]
 
 
 def decompose_multi_controlled_rotation(
-    matrix: np.ndarray, controls: list[cirq.Qid], target: cirq.Qid
+    matrix: np.ndarray, controls: Sequence[cirq.Qid], target: cirq.Qid
 ) -> list[cirq.Operation]:
     """Implements action of multi-controlled unitary gate.
 

cirq/transformers/analytical_decompositions/controlled_gate_decomposition_test.py

@@ -20,7 +20,7 @@ import scipy.stats
 import cirq
 
 
-def test_decompose_x():
+def test_decompose_x() -> None:
     """Verifies correctness of multi-controlled X decomposition."""
     for total_qubits_count in range(1, 8):
         qubits = cirq.LineQubit.range(total_qubits_count)
@@ -83,14 +83,14 @@ def _test_decompose(matrix, controls_count):
     cirq.testing.assert_allclose_up_to_global_phase(expected_matrix, result_matrix, atol=1e-8)
 
 
-def test_decompose_specific_matrices():
+def test_decompose_specific_matrices() -> None:
     for gate in [cirq.X, cirq.Y, cirq.Z, cirq.H, cirq.I, cirq.T, cirq.S]:
         for controls_count in range(7):
             _test_decompose(cirq.unitary(gate), controls_count)
 
 
 @cirq.testing.retry_once_with_later_random_values
-def test_decompose_random_unitary():
+def test_decompose_random_unitary() -> None:
     for controls_count in range(5):
         for _ in range(10):
             _test_decompose(_random_unitary(), controls_count)
@@ -99,7 +99,7 @@ def test_decompose_random_unitary():
 
 
 @cirq.testing.retry_once_with_later_random_values
-def test_decompose_random_special_unitary():
+def test_decompose_random_special_unitary() -> None:
     for controls_count in range(5):
         for _ in range(10):
             _test_decompose(_random_special_unitary(), controls_count)
@@ -113,7 +113,7 @@ def _decomposition_size(U, controls_count):
     return _count_operations(operations)
 
 
-def test_decompose_size_special_unitary():
+def test_decompose_size_special_unitary() -> None:
     np.random.seed(0)
     u = _random_special_unitary()
     assert _decomposition_size(u, 0) == (1, 0, 0)
@@ -126,7 +126,7 @@ def test_decompose_size_special_unitary():
         assert _decomposition_size(u, i) == (64 * i - 312, 48 * i - 234, 16)
 
 
-def test_decompose_size_unitary():
+def test_decompose_size_unitary() -> None:
     np.random.seed(0)
     u = _random_unitary()
     assert _decomposition_size(u, 0) == (1, 0, 0)

cirq/transformers/analytical_decompositions/cphase_to_fsim.py

@@ -14,7 +14,8 @@
 
 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
@@ -100,7 +101,7 @@ def decompose_cphase_into_two_fsim(
     fsim_gate: cirq.FSimGate,
     qubits: Sequence[cirq.Qid] | None = None,
     atol: float = 1e-8,
-) -> cirq.OP_TREE:
+) -> Sequence[cirq.Operation]:
     """Decomposes CZPowGate into two FSimGates.
 
     This function implements the decomposition described in section VII F I

cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py

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