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

cirq/transformers/measurement_transformers_test.py

@@ -23,7 +23,7 @@ import cirq
 from cirq.transformers.measurement_transformers import _ConfusionChannel, _MeasurementQid, _mod_add
 
 
-def assert_equivalent_to_deferred(circuit: cirq.Circuit):
+def assert_equivalent_to_deferred(circuit: cirq.Circuit) -> None:
     qubits = list(circuit.all_qubits())
     sim = cirq.Simulator()
     num_qubits = len(qubits)
@@ -40,7 +40,7 @@ def assert_equivalent_to_deferred(circuit: cirq.Circuit):
         np.testing.assert_equal(result.measurements, result1.measurements)
 
 
-def test_basic():
+def test_basic() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -61,7 +61,7 @@ def test_basic():
     )
 
 
-def test_qudits():
+def test_qudits() -> None:
     q0, q1 = cirq.LineQid.range(2, dimension=3)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -82,7 +82,7 @@ def test_qudits():
     )
 
 
-def test_sympy_control():
+def test_sympy_control() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -103,7 +103,7 @@ def test_sympy_control():
     )
 
 
-def test_sympy_qudits():
+def test_sympy_qudits() -> None:
     q0, q1 = cirq.LineQid.range(2, dimension=3)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -124,7 +124,7 @@ def test_sympy_qudits():
     )
 
 
-def test_sympy_control_complex():
+def test_sympy_control_complex() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -151,7 +151,7 @@ def test_sympy_control_complex():
     )
 
 
-def test_sympy_control_complex_qudit():
+def test_sympy_control_complex_qudit() -> None:
     q0, q1, q2 = cirq.LineQid.for_qid_shape((4, 2, 2))
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -180,7 +180,7 @@ def test_sympy_control_complex_qudit():
     )
 
 
-def test_multiple_sympy_control_complex():
+def test_multiple_sympy_control_complex() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -209,7 +209,7 @@ def test_multiple_sympy_control_complex():
     )
 
 
-def test_sympy_and_key_control():
+def test_sympy_and_key_control() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -230,7 +230,7 @@ def test_sympy_and_key_control():
     )
 
 
-def test_sympy_control_multiqubit():
+def test_sympy_control_multiqubit() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(
         cirq.measure(q0, q1, key='a'),
@@ -255,7 +255,7 @@ def test_sympy_control_multiqubit():
     )
 
 
-def test_nocompile_context():
+def test_nocompile_context() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a').with_tags('nocompile'),
@@ -268,7 +268,7 @@ def test_nocompile_context():
     cirq.testing.assert_same_circuits(deferred, circuit)
 
 
-def test_nocompile_context_leaves_invalid_circuit():
+def test_nocompile_context_leaves_invalid_circuit() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a').with_tags('nocompile'),
@@ -281,7 +281,7 @@ def test_nocompile_context_leaves_invalid_circuit():
         )
 
 
-def test_pauli():
+def test_pauli() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.PauliMeasurementGate(cirq.DensePauliString('Y'), key='a').on(q0),
@@ -303,7 +303,7 @@ def test_pauli():
     )
 
 
-def test_extra_measurements():
+def test_extra_measurements() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -326,7 +326,7 @@ def test_extra_measurements():
     )
 
 
-def test_extra_controlled_bits():
+def test_extra_controlled_bits() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -347,7 +347,7 @@ def test_extra_controlled_bits():
     )
 
 
-def test_extra_control_bits():
+def test_extra_control_bits() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -372,7 +372,7 @@ def test_extra_control_bits():
     )
 
 
-def test_subcircuit():
+def test_subcircuit() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.CircuitOperation(
@@ -397,7 +397,7 @@ def test_subcircuit():
     )
 
 
-def test_multi_qubit_measurements():
+def test_multi_qubit_measurements() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, q1, key='a'),
@@ -422,7 +422,7 @@ def test_multi_qubit_measurements():
     )
 
 
-def test_multi_qubit_control():
+def test_multi_qubit_control() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(
         cirq.measure(q0, q1, key='a'),
@@ -448,7 +448,7 @@ def test_multi_qubit_control():
 
 
 @pytest.mark.parametrize('index', [-3, -2, -1, 0, 1, 2])
-def test_repeated(index: int):
+def test_repeated(index: int) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),  # The control measurement when `index` is 0 or -2
@@ -481,7 +481,7 @@ def test_repeated(index: int):
     )
 
 
-def test_diagram():
+def test_diagram() -> None:
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     circuit = cirq.Circuit(
         cirq.measure(q0, q2, key='a'),
@@ -515,7 +515,7 @@ M('b[0]', q=q(3)): ───────X────M────────
     )
 
 
-def test_repr():
+def test_repr() -> None:
     def test_repr(qid: _MeasurementQid):
         cirq.testing.assert_equivalent_repr(qid, global_vals={'_MeasurementQid': _MeasurementQid})
 
@@ -526,7 +526,7 @@ def test_repr():
     test_repr(_MeasurementQid('0:1:a', cirq.LineQid(9, 4)))
 
 
-def test_confusion_map():
+def test_confusion_map() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.H(q0),
@@ -549,7 +549,7 @@ def test_confusion_map():
     assert np.all(result['a'] == result['b'])
 
 
-def test_confusion_map_density_matrix():
+def test_confusion_map_density_matrix() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     p_q0 = 0.3  # probability to measure 1 for q0
     confusion = np.array([[0.8, 0.2], [0.1, 0.9]])
@@ -573,20 +573,20 @@ def test_confusion_map_density_matrix():
     assert np.allclose(cirq.partial_trace(rho, [2]), expected)
 
 
-def test_confusion_map_invert_mask_ordering():
+def test_confusion_map_invert_mask_ordering() -> None:
     q0 = cirq.LineQubit(0)
     # Confusion map sets the measurement to zero, and the invert mask changes it to one.
     # If these are run out of order then the result would be zero.
     circuit = cirq.Circuit(
         cirq.measure(
-            q0, key='a', confusion_map={(0,): np.array([[1, 0], [1, 0]])}, invert_mask=(1,)
+            q0, key='a', confusion_map={(0,): np.array([[1, 0], [1, 0]])}, invert_mask=(True,)
         ),
         cirq.I(q0),
     )
     assert_equivalent_to_deferred(circuit)
 
 
-def test_confusion_map_qudits():
+def test_confusion_map_qudits() -> None:
     q0 = cirq.LineQid(0, dimension=3)
     # First op takes q0 to superposed state, then confusion map measures 2 regardless.
     circuit = cirq.Circuit(
@@ -599,7 +599,7 @@ def test_confusion_map_qudits():
     assert_equivalent_to_deferred(circuit)
 
 
-def test_multi_qubit_confusion_map():
+def test_multi_qubit_confusion_map() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(
         cirq.measure(
@@ -638,7 +638,7 @@ def test_multi_qubit_confusion_map():
     assert np.sum(result['b']) == 100
 
 
-def test_confusion_map_errors():
+def test_confusion_map_errors() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a', confusion_map={(0,): np.array([1])}),
@@ -676,7 +676,7 @@ def test_confusion_map_errors():
         _ = cirq.defer_measurements(circuit)
 
 
-def test_dephase():
+def test_dephase() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.CircuitOperation(
@@ -704,7 +704,7 @@ def test_dephase():
     )
 
 
-def test_dephase_classical_conditions():
+def test_dephase_classical_conditions() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.measure(q0, key='a'),
@@ -715,7 +715,7 @@ def test_dephase_classical_conditions():
         _ = cirq.dephase_measurements(circuit)
 
 
-def test_dephase_nocompile_context():
+def test_dephase_nocompile_context() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.CircuitOperation(
@@ -745,11 +745,13 @@ def test_dephase_nocompile_context():
     )
 
 
-def test_drop_terminal():
+def test_drop_terminal() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.CircuitOperation(
-            cirq.FrozenCircuit(cirq.CX(q0, q1), cirq.measure(q0, q1, key='a~b', invert_mask=[0, 1]))
+            cirq.FrozenCircuit(
+                cirq.CX(q0, q1), cirq.measure(q0, q1, key='a~b', invert_mask=(False, True))
+            )
         )
     )
     dropped = cirq.drop_terminal_measurements(circuit)
@@ -761,10 +763,12 @@ def test_drop_terminal():
     )
 
 
-def test_drop_terminal_qudit():
+def test_drop_terminal_qudit() -> None:
     q0, q1 = cirq.LineQid.range(2, dimension=3)
     circuit = cirq.Circuit(
-        cirq.CircuitOperation(cirq.FrozenCircuit(cirq.measure(q0, q1, key='m', invert_mask=[0, 1])))
+        cirq.CircuitOperation(
+            cirq.FrozenCircuit(cirq.measure(q0, q1, key='m', invert_mask=(False, True)))
+        )
     )
     dropped = cirq.drop_terminal_measurements(circuit)
     expected_inversion_matrix = np.array([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
@@ -796,11 +800,13 @@ def test_drop_terminal_qudit():
     assert np.all(d2.measurements['m'] == [2, 2])
 
 
-def test_drop_terminal_nonterminal_error():
+def test_drop_terminal_nonterminal_error() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.CircuitOperation(
-            cirq.FrozenCircuit(cirq.measure(q0, q1, key='a~b', invert_mask=[0, 1]), cirq.CX(q0, q1))
+            cirq.FrozenCircuit(
+                cirq.measure(q0, q1, key='a~b', invert_mask=(False, True)), cirq.CX(q0, q1)
+            )
         )
     )
     with pytest.raises(ValueError, match='Circuit contains a non-terminal measurement'):
@@ -813,7 +819,7 @@ def test_drop_terminal_nonterminal_error():
         _ = cirq.drop_terminal_measurements(circuit, context=None)
 
 
-def test_confusion_channel_consistency():
+def test_confusion_channel_consistency() -> None:
     two_d_chan = _ConfusionChannel(np.array([[0.5, 0.5], [0.4, 0.6]]), shape=(2,))
     cirq.testing.assert_has_consistent_apply_channel(two_d_chan)
     three_d_chan = _ConfusionChannel(

cirq/transformers/merge_k_qubit_gates.py

@@ -16,7 +16,8 @@
 
 from __future__ import annotations
 
-from typing import Callable, cast, TYPE_CHECKING
+from collections.abc import Callable
+from typing import cast, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
 from cirq.transformers import transformer_api, transformer_primitives

cirq/transformers/merge_k_qubit_gates_test.py

@@ -20,7 +20,7 @@ import pytest
 import cirq
 
 
-def assert_optimizes(optimized: cirq.AbstractCircuit, expected: cirq.AbstractCircuit):
+def assert_optimizes(optimized: cirq.AbstractCircuit, expected: cirq.AbstractCircuit) -> None:
     # Ignore differences that would be caught by follow-up optimizations.
     followup_transformers: list[cirq.TRANSFORMER] = [
         cirq.drop_negligible_operations,

cirq/transformers/merge_single_qubit_gates.py

@@ -16,7 +16,8 @@
 
 from __future__ import annotations
 
-from typing import Callable, cast, Hashable, TYPE_CHECKING
+from collections.abc import Callable, Hashable
+from typing import cast, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
 from cirq.study.resolver import ParamResolver
@@ -323,9 +324,12 @@ def merge_single_qubit_gates_to_phxz_symbolized(
     )
 
     # Step 3, get N sets of parameterizations as new_sweep.
-    new_sweep = Zip(
-        _calc_phxz_sweeps(new_circuit, merged_circuits),  # phxz sweeps
-        _sweep_on_symbols(sweep, remaining_symbols),  # remaining sweeps
-    )
+    if remaining_symbols:
+        new_sweep: Sweep = Zip(
+            _calc_phxz_sweeps(new_circuit, merged_circuits),  # phxz sweeps
+            _sweep_on_symbols(sweep, remaining_symbols),  # remaining sweeps
+        )
+    else:
+        new_sweep = _calc_phxz_sweeps(new_circuit, merged_circuits)
 
     return align.align_right(new_circuit), new_sweep

cirq/transformers/merge_single_qubit_gates_test.py

@@ -21,7 +21,7 @@ import sympy
 import cirq
 
 
-def assert_optimizes(optimized: cirq.AbstractCircuit, expected: cirq.AbstractCircuit):
+def assert_optimizes(optimized: cirq.AbstractCircuit, expected: cirq.AbstractCircuit) -> None:
     # Ignore differences that would be caught by follow-up optimizations.
     followup_transformers: list[cirq.TRANSFORMER] = [
         cirq.drop_negligible_operations,
@@ -34,7 +34,7 @@ def assert_optimizes(optimized: cirq.AbstractCircuit, expected: cirq.AbstractCir
     cirq.testing.assert_same_circuits(optimized, expected)
 
 
-def test_merge_single_qubit_gates_to_phased_x_and_z():
+def test_merge_single_qubit_gates_to_phased_x_and_z() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit(
         cirq.X(a),
@@ -58,7 +58,7 @@ def test_merge_single_qubit_gates_to_phased_x_and_z():
     )
 
 
-def test_merge_single_qubit_gates_to_phased_x_and_z_deep():
+def test_merge_single_qubit_gates_to_phased_x_and_z_deep() -> None:
     a = cirq.NamedQubit("a")
     c_nested = cirq.FrozenCircuit(cirq.H(a), cirq.Z(a), cirq.H(a).with_tags("ignore"))
     c_nested_merged = cirq.FrozenCircuit(
@@ -80,7 +80,7 @@ def test_merge_single_qubit_gates_to_phased_x_and_z_deep():
         c_nested_merged,
         cirq.CircuitOperation(c_nested_merged).repeat(6),
     )
-    context = cirq.TransformerContext(tags_to_ignore=["ignore"], deep=True)
+    context = cirq.TransformerContext(tags_to_ignore=("ignore",), deep=True)
     c_new = cirq.merge_single_qubit_gates_to_phased_x_and_z(c_orig, context=context)
     cirq.testing.assert_same_circuits(c_new, c_expected)
 
@@ -89,7 +89,7 @@ def _phxz(a: float | sympy.Symbol, x: float | sympy.Symbol, z: float | sympy.Sym
     return cirq.PhasedXZGate(axis_phase_exponent=a, x_exponent=x, z_exponent=z)
 
 
-def test_merge_single_qubit_gates_to_phxz():
+def test_merge_single_qubit_gates_to_phxz() -> None:
     a, b = cirq.LineQubit.range(2)
     c = cirq.Circuit(
         cirq.X(a),
@@ -113,7 +113,7 @@ def test_merge_single_qubit_gates_to_phxz():
     )
 
 
-def test_merge_single_qubit_gates_to_phxz_deep():
+def test_merge_single_qubit_gates_to_phxz_deep() -> None:
     a = cirq.NamedQubit("a")
     c_nested = cirq.FrozenCircuit(cirq.H(a), cirq.Z(a), cirq.H(a).with_tags("ignore"))
     c_nested_merged = cirq.FrozenCircuit(_phxz(-0.5, 0.5, 0).on(a), cirq.H(a).with_tags("ignore"))
@@ -133,12 +133,12 @@ def test_merge_single_qubit_gates_to_phxz_deep():
         c_nested_merged,
         cirq.CircuitOperation(c_nested_merged).repeat(6),
     )
-    context = cirq.TransformerContext(tags_to_ignore=["ignore"], deep=True)
+    context = cirq.TransformerContext(tags_to_ignore=("ignore",), deep=True)
     c_new = cirq.merge_single_qubit_gates_to_phxz(c_orig, context=context)
     cirq.testing.assert_same_circuits(c_new, c_expected)
 
 
-def test_merge_single_qubit_moments_to_phxz():
+def test_merge_single_qubit_moments_to_phxz() -> None:
     q = cirq.LineQubit.range(3)
     c_orig = cirq.Circuit(
         cirq.Moment(cirq.X.on_each(*q[:2])),
@@ -182,7 +182,7 @@ a: ═════════════════════════
     )
 
 
-def test_merge_single_qubit_moments_to_phxz_deep():
+def test_merge_single_qubit_moments_to_phxz_deep() -> None:
     q = cirq.LineQubit.range(3)
     x_t_y = cirq.FrozenCircuit(
         cirq.Moment(cirq.X.on_each(*q[:2])),
@@ -218,20 +218,20 @@ def test_merge_single_qubit_moments_to_phxz_deep():
         c_nested_merged,
         cirq.CircuitOperation(c_nested_merged).repeat(6),
     )
-    context = cirq.TransformerContext(tags_to_ignore=["ignore"], deep=True)
+    context = cirq.TransformerContext(tags_to_ignore=("ignore",), deep=True)
     c_new = cirq.merge_single_qubit_moments_to_phxz(c_orig, context=context)
     cirq.testing.assert_allclose_up_to_global_phase(
         c_new.unitary(), c_expected.unitary(), atol=1e-7
     )
 
 
-def test_merge_single_qubit_gates_to_phxz_global_phase():
+def test_merge_single_qubit_gates_to_phxz_global_phase() -> None:
     c = cirq.Circuit(cirq.GlobalPhaseGate(1j).on())
     c2 = cirq.merge_single_qubit_gates_to_phxz(c)
     assert c == c2
 
 
-def test_merge_single_qubit_gates_to_phased_x_and_z_global_phase():
+def test_merge_single_qubit_gates_to_phased_x_and_z_global_phase() -> None:
     c = cirq.Circuit(cirq.GlobalPhaseGate(1j).on())
     c2 = cirq.merge_single_qubit_gates_to_phased_x_and_z(c)
     assert c == c2
@@ -240,7 +240,7 @@ def test_merge_single_qubit_gates_to_phased_x_and_z_global_phase():
 class TestMergeSingleQubitGatesSymbolized(TestCase):
     """Test suite for merge_single_qubit_gates_to_phxz_symbolized."""
 
-    def test_case1(self):
+    def test_case1(self) -> None:
         """Test case diagram.
         Input circuit:
         0: ───X─────────@────────H[ignore]─H──X──PhXZ(a=a0,x=x0,z=z0)──X──PhXZ(a=a1,x=x1,z=z1)───
@@ -265,7 +265,7 @@ class TestMergeSingleQubitGatesSymbolized(TestCase):
             cirq.Moment(cirq.X(a)),
             cirq.Moment(_phxz(sa1, sx1, sz1).on(a)),
         )
-        context = cirq.TransformerContext(tags_to_ignore=["ignore"])
+        context = cirq.TransformerContext(tags_to_ignore=("ignore",))
         sweep = cirq.Zip(
             cirq.Points(key="h_exp", points=[0, 1]),
             cirq.Points(key="cz_exp", points=[0, 1]),
@@ -295,7 +295,7 @@ class TestMergeSingleQubitGatesSymbolized(TestCase):
                 {q: q for q in input_circuit.all_qubits()},
             )
 
-    def test_with_gauge_compiling_as_sweep_success(self):
+    def test_with_gauge_compiling_as_sweep_success(self) -> None:
         qubits = cirq.LineQubit.range(7)
         c = cirq.Circuit(
             cirq.Moment(cirq.H(qubits[0]), cirq.H(qubits[3])),
@@ -318,7 +318,7 @@ class TestMergeSingleQubitGatesSymbolized(TestCase):
                 {q: q for q in qubits},
             )
 
-    def test_case_non_parameterized_singles(self):
+    def test_case_non_parameterized_singles(self) -> None:
         """Test merge_single_qubit_gates_to_phxz_symbolized when all single qubit gates are not
         parameterized."""
 
@@ -330,7 +330,7 @@ class TestMergeSingleQubitGatesSymbolized(TestCase):
         )
         assert_optimizes(output_circuit, expected_circuit)
 
-    def test_fail_different_structures_error(self):
+    def test_fail_different_structures_error(self) -> None:
         """Tests that the function raises a ValueError if merged structures of the circuit differ
         for different parameterizations."""
         q0, q1 = cirq.LineQubit.range(2)
@@ -347,7 +347,7 @@ class TestMergeSingleQubitGatesSymbolized(TestCase):
             with pytest.raises(ValueError, match="Expect a PhasedXZGate or IdentityGate.*"):
                 cirq.merge_single_qubit_gates_to_phxz_symbolized(circuit, sweep=sweep)
 
-    def test_fail_unexpected_gate_error(self):
+    def test_fail_unexpected_gate_error(self) -> None:
         """Tests that the function raises a RuntimeError of unexpected gate."""
         a, b = cirq.LineQubit.range(2)
         circuit = cirq.Circuit(
@@ -373,7 +373,7 @@ class TestMergeSingleQubitGatesSymbolized(TestCase):
                 cirq.merge_single_qubit_gates_to_phxz_symbolized(circuit, sweep=sweep)
 
 
-def test_merge_single_qubit_moments_to_phxz_with_global_phase_in_first_moment():
+def test_merge_single_qubit_moments_to_phxz_with_global_phase_in_first_moment() -> None:
     q0 = cirq.LineQubit(0)
     c_orig = cirq.Circuit(
         cirq.Moment(cirq.Y(q0) ** 0.5, cirq.GlobalPhaseGate(1j**0.5).on()), cirq.Moment(cirq.X(q0))
@@ -384,12 +384,12 @@ def test_merge_single_qubit_moments_to_phxz_with_global_phase_in_first_moment():
             cirq.GlobalPhaseGate(1j**0.5).on(),
         )
     )
-    context = cirq.TransformerContext(tags_to_ignore=["ignore"])
+    context = cirq.TransformerContext(tags_to_ignore=("ignore",))
     c_new = cirq.merge_single_qubit_moments_to_phxz(c_orig, context=context)
     assert c_new == c_expected
 
 
-def test_merge_single_qubit_moments_to_phxz_with_global_phase_in_second_moment():
+def test_merge_single_qubit_moments_to_phxz_with_global_phase_in_second_moment() -> None:
     q0 = cirq.LineQubit(0)
     c_orig = cirq.Circuit(
         cirq.Moment(cirq.Y(q0) ** 0.5), cirq.Moment(cirq.X(q0), cirq.GlobalPhaseGate(1j**0.5).on())
@@ -400,6 +400,6 @@ def test_merge_single_qubit_moments_to_phxz_with_global_phase_in_second_moment()
             cirq.GlobalPhaseGate(1j**0.5).on(),
         )
     )
-    context = cirq.TransformerContext(tags_to_ignore=["ignore"])
+    context = cirq.TransformerContext(tags_to_ignore=("ignore",))
     c_new = cirq.merge_single_qubit_moments_to_phxz(c_orig, context=context)
     assert c_new == c_expected

cirq/transformers/noise_adding_test.py

@@ -20,7 +20,7 @@ import cirq.transformers.noise_adding as na
 from cirq import circuits, devices, ops
 
 
-def test_noise_adding():
+def test_noise_adding() -> None:
     qubits = devices.LineQubit.range(4)
     one_layer = circuits.Circuit(ops.CZ(*qubits[:2]), ops.CZ(*qubits[2:]))
     circuit = one_layer * 10
@@ -48,7 +48,7 @@ def test_noise_adding():
 
     # test that supplying a dictionary for p works
     transformed_circuit_p_dict = na.DepolarizingNoiseTransformer(
-        {tuple(qubits[:2]): 1.0, tuple(qubits[2:]): 0.0}
+        {(qubits[0], qubits[1]): 1.0, (qubits[2], qubits[3]): 0.0}
     )(circuit)
     assert len(transformed_circuit_p_dict) == 20  # depth should be doubled
     assert transformed_circuit_p_dict[1::2].all_qubits() == frozenset(

cirq/transformers/optimize_for_target_gateset.py

@@ -16,7 +16,8 @@
 
 from __future__ import annotations
 
-from typing import Callable, Hashable, Sequence, TYPE_CHECKING
+from collections.abc import Callable, Hashable, Sequence
+from typing import TYPE_CHECKING
 
 from cirq import circuits
 from cirq.protocols import decompose_protocol as dp

cirq/transformers/optimize_for_target_gateset_test.py

@@ -25,7 +25,7 @@ if TYPE_CHECKING:
     from cirq.protocols.decompose_protocol import DecomposeResult
 
 
-def test_decompose_operations_raises_on_stuck():
+def test_decompose_operations_raises_on_stuck() -> None:
     c_orig = cirq.Circuit(cirq.X(cirq.NamedQubit("q")).with_tags("ignore"))
     gateset = cirq.Gateset(cirq.Y)
     with pytest.raises(ValueError, match="Unable to convert"):
@@ -41,7 +41,7 @@ def test_decompose_operations_raises_on_stuck():
     cirq.testing.assert_same_circuits(c_orig, c_new)
 
 
-def test_decompose_operations_to_target_gateset_default():
+def test_decompose_operations_to_target_gateset_default() -> None:
     q = cirq.LineQubit.range(2)
     c_orig = cirq.Circuit(
         cirq.T(q[0]),
@@ -77,7 +77,7 @@ m: ═════════════════════════
     )
 
 
-def test_decompose_operations_to_target_gateset():
+def test_decompose_operations_to_target_gateset() -> None:
     q = cirq.LineQubit.range(2)
     c_orig = cirq.Circuit(
         cirq.T(q[0]),
@@ -130,7 +130,7 @@ class MatrixGateTargetGateset(cirq.CompilationTargetGateset):
         return cirq.MatrixGate(cirq.unitary(op), name="M").on(*op.qubits)
 
 
-def test_optimize_for_target_gateset_default():
+def test_optimize_for_target_gateset_default() -> None:
     q = cirq.LineQubit.range(2)
     c_orig = cirq.Circuit(
         cirq.T(q[0]), cirq.SWAP(*q), cirq.T(q[0]), cirq.SWAP(*q).with_tags("ignore")
@@ -148,7 +148,7 @@ def test_optimize_for_target_gateset_default():
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(c_orig, c_new, atol=1e-6)
 
 
-def test_optimize_for_target_gateset():
+def test_optimize_for_target_gateset() -> None:
     q = cirq.LineQubit.range(4)
     c_orig = cirq.Circuit(
         cirq.QuantumFourierTransformGate(4).on(*q),
@@ -201,7 +201,7 @@ m: ═════════════════════════
         )
 
 
-def test_optimize_for_target_gateset_deep():
+def test_optimize_for_target_gateset_deep() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     c_nested = cirq.FrozenCircuit(cirq.CX(q0, q1))
     c_orig = cirq.Circuit(
@@ -209,10 +209,12 @@ def test_optimize_for_target_gateset_deep():
             cirq.FrozenCircuit(cirq.H(q0), cirq.CircuitOperation(c_nested).repeat(3))
         ).repeat(5)
     )
+    phxz_from_h_unitary = cirq.single_qubit_matrix_to_phxz(cirq.unitary(cirq.H(q0)))
+    assert phxz_from_h_unitary is not None
     c_expected = cirq.Circuit(
         cirq.CircuitOperation(
             cirq.FrozenCircuit(
-                cirq.single_qubit_matrix_to_phxz(cirq.unitary(cirq.H(q0))).on(q0),
+                phxz_from_h_unitary.on(q0),
                 cirq.CircuitOperation(
                     cirq.FrozenCircuit(
                         cirq.MatrixGate(c_nested.unitary(qubit_order=[q0, q1]), name="M").on(q0, q1)
@@ -252,7 +254,7 @@ def test_optimize_for_target_gateset_deep():
 
 
 @pytest.mark.parametrize('max_num_passes', [2, None])
-def test_optimize_for_target_gateset_multiple_passes(max_num_passes: int | None):
+def test_optimize_for_target_gateset_multiple_passes(max_num_passes: int | None) -> None:
     gateset = cirq.CZTargetGateset()
 
     input_circuit = cirq.Circuit(
@@ -332,7 +334,7 @@ def test_optimize_for_target_gateset_multiple_passes(max_num_passes: int | None)
 @pytest.mark.parametrize('max_num_passes', [2, None])
 def test_optimize_for_target_gateset_multiple_passes_dont_preserve_moment_structure(
     max_num_passes: int | None,
-):
+) -> None:
     gateset = cirq.CZTargetGateset(preserve_moment_structure=False)
 
     input_circuit = cirq.Circuit(