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

cirq/transformers/eject_phased_paulis.py

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

cirq/transformers/eject_phased_paulis_test.py

@@ -15,7 +15,8 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import cast, Iterable
+from collections.abc import Iterable
+from typing import cast
 
 import numpy as np
 import pytest
@@ -31,7 +32,7 @@ def assert_optimizes(
     eject_parameterized: bool = False,
     *,
     with_context: bool = False,
-):
+) -> None:
     context = cirq.TransformerContext(tags_to_ignore=("nocompile",)) if with_context else None
     circuit = cirq.eject_phased_paulis(
         before, eject_parameterized=eject_parameterized, context=context

cirq/transformers/eject_z.py

@@ -17,7 +17,8 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Iterable, Iterator, TYPE_CHECKING
+from collections.abc import Iterable, Iterator
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -29,11 +30,11 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _is_integer(n):
+def _is_integer(n) -> bool:
     return np.isclose(n, np.round(n))
 
 
-def _is_swaplike(gate: cirq.Gate):
+def _is_swaplike(gate: cirq.Gate) -> bool:
     if isinstance(gate, ops.SwapPowGate):
         return gate.exponent == 1
 
@@ -119,6 +120,7 @@ def eject_z(
             return []
 
         # Try to move the tracked phases over the operation via protocols.phase_by(op)
+        phased_op: cirq.Operation | None
         phased_op = op
         for i, p in enumerate([qubit_phase[q] for q in op.qubits]):
             if not single_qubit_decompositions.is_negligible_turn(p, atol):

cirq/transformers/eject_z_test.py

@@ -30,7 +30,7 @@ def assert_optimizes(
     eject_parameterized: bool = False,
     *,
     with_context: bool = False,
-):
+) -> None:
     if cirq.has_unitary(before):
         cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
             before, expected, atol=1e-8
@@ -72,7 +72,7 @@ def assert_optimizes(
     cirq.testing.assert_same_circuits(c_nested, c_expected)
 
 
-def assert_removes_all_z_gates(circuit: cirq.Circuit, eject_parameterized: bool = True):
+def assert_removes_all_z_gates(circuit: cirq.Circuit, eject_parameterized: bool = True) -> None:
     optimized = cirq.eject_z(circuit, eject_parameterized=eject_parameterized)
     for op in optimized.all_operations():
         # assert _try_get_known_z_half_turns(op, eject_parameterized) is None
@@ -96,7 +96,7 @@ def assert_removes_all_z_gates(circuit: cirq.Circuit, eject_parameterized: bool
         )
 
 
-def test_single_z_stays():
+def test_single_z_stays() -> None:
     q = cirq.NamedQubit('q')
     assert_optimizes(
         before=cirq.Circuit([cirq.Moment([cirq.Z(q) ** 0.5])]),
@@ -104,13 +104,13 @@ def test_single_z_stays():
     )
 
 
-def test_single_phased_xz_stays():
+def test_single_phased_xz_stays() -> None:
     gate = cirq.PhasedXZGate(axis_phase_exponent=0.2, x_exponent=0.3, z_exponent=0.4)
     q = cirq.NamedQubit('q')
     assert_optimizes(before=cirq.Circuit(gate(q)), expected=cirq.Circuit(gate(q)))
 
 
-def test_ignores_xz_and_cz():
+def test_ignores_xz_and_cz() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     assert_optimizes(
@@ -135,7 +135,7 @@ def test_ignores_xz_and_cz():
     )
 
 
-def test_early_z():
+def test_early_z() -> None:
     q = cirq.NamedQubit('q')
     assert_optimizes(
         before=cirq.Circuit([cirq.Moment([cirq.Z(q) ** 0.5]), cirq.Moment(), cirq.Moment()]),
@@ -143,7 +143,7 @@ def test_early_z():
     )
 
 
-def test_multi_z_merges():
+def test_multi_z_merges() -> None:
     q = cirq.NamedQubit('q')
     assert_optimizes(
         before=cirq.Circuit([cirq.Moment([cirq.Z(q) ** 0.5]), cirq.Moment([cirq.Z(q) ** 0.25])]),
@@ -151,7 +151,7 @@ def test_multi_z_merges():
     )
 
 
-def test_z_pushes_past_xy_and_phases_it():
+def test_z_pushes_past_xy_and_phases_it() -> None:
     q = cirq.NamedQubit('q')
     assert_optimizes(
         before=cirq.Circuit([cirq.Moment([cirq.Z(q) ** 0.5]), cirq.Moment([cirq.Y(q) ** 0.25])]),
@@ -161,7 +161,7 @@ def test_z_pushes_past_xy_and_phases_it():
     )
 
 
-def test_z_pushes_past_cz():
+def test_z_pushes_past_cz() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     assert_optimizes(
@@ -174,7 +174,7 @@ def test_z_pushes_past_cz():
     )
 
 
-def test_measurement_consumes_zs():
+def test_measurement_consumes_zs() -> None:
     q = cirq.NamedQubit('q')
     assert_optimizes(
         before=cirq.Circuit(
@@ -188,7 +188,7 @@ def test_measurement_consumes_zs():
     )
 
 
-def test_unphaseable_causes_earlier_merge_without_size_increase():
+def test_unphaseable_causes_earlier_merge_without_size_increase() -> None:
     class UnknownGate(cirq.testing.SingleQubitGate):
         pass
 
@@ -222,7 +222,7 @@ def test_unphaseable_causes_earlier_merge_without_size_increase():
 
 
 @pytest.mark.parametrize('sym', [sympy.Symbol('a'), sympy.Symbol('a') + 1])
-def test_symbols_block(sym):
+def test_symbols_block(sym) -> None:
     q = cirq.NamedQubit('q')
     assert_optimizes(
         before=cirq.Circuit(
@@ -239,7 +239,7 @@ def test_symbols_block(sym):
 
 
 @pytest.mark.parametrize('sym', [sympy.Symbol('a'), sympy.Symbol('a') + 1])
-def test_symbols_eject(sym):
+def test_symbols_eject(sym) -> None:
     q = cirq.NamedQubit('q')
     assert_optimizes(
         before=cirq.Circuit(
@@ -256,7 +256,7 @@ def test_symbols_eject(sym):
     )
 
 
-def test_removes_zs():
+def test_removes_zs() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -295,7 +295,7 @@ def test_removes_zs():
     )
 
 
-def test_unknown_operation_blocks():
+def test_unknown_operation_blocks() -> None:
     q = cirq.NamedQubit('q')
 
     class UnknownOp(cirq.Operation):
@@ -314,7 +314,7 @@ def test_unknown_operation_blocks():
     )
 
 
-def test_tagged_nocompile_operation_blocks():
+def test_tagged_nocompile_operation_blocks() -> None:
     q = cirq.NamedQubit('q')
     u = cirq.Z(q).with_tags("nocompile")
     assert_optimizes(
@@ -324,7 +324,7 @@ def test_tagged_nocompile_operation_blocks():
     )
 
 
-def test_swap():
+def test_swap() -> None:
     a, b = cirq.LineQubit.range(2)
     original = cirq.Circuit([cirq.rz(0.123).on(a), cirq.SWAP(a, b)])
     optimized = original.copy()
@@ -341,13 +341,12 @@ def test_swap():
 
 
 @pytest.mark.parametrize('exponent', (0, 2, 1.1, -2, -1.6))
-def test_not_a_swap(exponent):
-    a, b = cirq.LineQubit.range(2)
-    assert not _is_swaplike(cirq.SWAP(a, b) ** exponent)
+def test_not_a_swap(exponent: float) -> None:
+    assert not _is_swaplike(cirq.SWAP**exponent)
 
 
 @pytest.mark.parametrize('theta', (np.pi / 2, -np.pi / 2, np.pi / 2 + 5 * np.pi))
-def test_swap_fsim(theta):
+def test_swap_fsim(theta) -> None:
     a, b = cirq.LineQubit.range(2)
     original = cirq.Circuit([cirq.rz(0.123).on(a), cirq.FSimGate(theta=theta, phi=0.123).on(a, b)])
     optimized = original.copy()
@@ -364,13 +363,12 @@ def test_swap_fsim(theta):
 
 
 @pytest.mark.parametrize('theta', (0, 5 * np.pi, -np.pi))
-def test_not_a_swap_fsim(theta):
-    a, b = cirq.LineQubit.range(2)
-    assert not _is_swaplike(cirq.FSimGate(theta=theta, phi=0.456).on(a, b))
+def test_not_a_swap_fsim(theta) -> None:
+    assert not _is_swaplike(cirq.FSimGate(theta=theta, phi=0.456))
 
 
 @pytest.mark.parametrize('exponent', (1, -1))
-def test_swap_iswap(exponent):
+def test_swap_iswap(exponent) -> None:
     a, b = cirq.LineQubit.range(2)
     original = cirq.Circuit([cirq.rz(0.123).on(a), cirq.ISWAP(a, b) ** exponent])
     optimized = original.copy()

cirq/transformers/expand_composite.py

@@ -16,7 +16,8 @@
 
 from __future__ import annotations
 
-from typing import Callable, TYPE_CHECKING
+from collections.abc import Callable
+from typing import TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
 from cirq.transformers import transformer_api, transformer_primitives
@@ -31,7 +32,7 @@ def expand_composite(
     *,
     context: cirq.TransformerContext | None = None,
     no_decomp: Callable[[ops.Operation], bool] = (lambda _: False),
-):
+) -> cirq.Circuit:
     """A transformer that expands composite operations via `cirq.decompose`.
 
     For each operation in the circuit, this pass examines if the operation can

cirq/transformers/expand_composite_test.py

@@ -19,24 +19,24 @@ from __future__ import annotations
 import cirq
 
 
-def assert_equal_mod_empty(expected, actual):
+def assert_equal_mod_empty(expected, actual) -> None:
     actual = cirq.drop_empty_moments(actual)
     cirq.testing.assert_same_circuits(actual, expected)
 
 
-def test_empty_circuit():
+def test_empty_circuit() -> None:
     circuit = cirq.Circuit()
     circuit = cirq.expand_composite(circuit)
     assert_equal_mod_empty(cirq.Circuit(), circuit)
 
 
-def test_empty_moment():
+def test_empty_moment() -> None:
     circuit = cirq.Circuit([])
     circuit = cirq.expand_composite(circuit)
     assert_equal_mod_empty(cirq.Circuit([]), circuit)
 
 
-def test_ignore_non_composite():
+def test_ignore_non_composite() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit()
     circuit.append([cirq.X(q0), cirq.Y(q1), cirq.CZ(q0, q1), cirq.Z(q0)])
@@ -45,7 +45,7 @@ def test_ignore_non_composite():
     assert_equal_mod_empty(expected, circuit)
 
 
-def test_composite_default():
+def test_composite_default() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     cnot = cirq.CNOT(q0, q1)
     circuit = cirq.Circuit()
@@ -56,7 +56,7 @@ def test_composite_default():
     assert_equal_mod_empty(expected, circuit)
 
 
-def test_multiple_composite_default():
+def test_multiple_composite_default() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     cnot = cirq.CNOT(q0, q1)
     circuit = cirq.Circuit()
@@ -68,7 +68,7 @@ def test_multiple_composite_default():
     assert_equal_mod_empty(expected, circuit)
 
 
-def test_mix_composite_non_composite():
+def test_mix_composite_non_composite() -> None:
     q0, q1 = cirq.LineQubit.range(2)
 
     circuit = cirq.Circuit(cirq.X(q0), cirq.CNOT(q0, q1), cirq.X(q1))
@@ -85,7 +85,7 @@ def test_mix_composite_non_composite():
     assert_equal_mod_empty(expected, circuit)
 
 
-def test_recursive_composite():
+def test_recursive_composite() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     swap = cirq.SWAP(q0, q1)
     circuit = cirq.Circuit()
@@ -106,7 +106,7 @@ def test_recursive_composite():
     assert_equal_mod_empty(expected, circuit)
 
 
-def test_decompose_returns_not_flat_op_tree():
+def test_decompose_returns_not_flat_op_tree() -> None:
     class ExampleGate(cirq.testing.SingleQubitGate):
         def _decompose_(self, qubits):
             (q0,) = qubits
@@ -121,7 +121,7 @@ def test_decompose_returns_not_flat_op_tree():
     assert_equal_mod_empty(expected, circuit)
 
 
-def test_decompose_returns_deep_op_tree():
+def test_decompose_returns_deep_op_tree() -> None:
     class ExampleGate(cirq.testing.TwoQubitGate):
         def _decompose_(self, qubits):
             q0, q1 = qubits
@@ -162,7 +162,7 @@ def test_decompose_returns_deep_op_tree():
     assert_equal_mod_empty(expected, circuit)
 
 
-def test_non_recursive_expansion():
+def test_non_recursive_expansion() -> None:
     qubits = [cirq.NamedQubit(s) for s in 'xy']
     no_decomp = lambda op: (isinstance(op, cirq.GateOperation) and op.gate == cirq.ISWAP)
     unexpanded_circuit = cirq.Circuit(cirq.ISWAP(*qubits))
@@ -184,14 +184,14 @@ y: ───X───────@───────@───────
     assert actual_text_diagram == expected_text_diagram
 
 
-def test_do_not_decompose_no_compile():
+def test_do_not_decompose_no_compile() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.CNOT(q0, q1).with_tags("no_compile"))
     context = cirq.TransformerContext(tags_to_ignore=("no_compile",))
     assert_equal_mod_empty(c, cirq.expand_composite(c, context=context))
 
 
-def test_expands_composite_recursively_preserving_structure():
+def test_expands_composite_recursively_preserving_structure() -> None:
     q = cirq.LineQubit.range(2)
     c_nested = cirq.FrozenCircuit(
         cirq.SWAP(*q[:2]), cirq.SWAP(*q[:2]).with_tags("ignore"), cirq.SWAP(*q[:2])
@@ -256,7 +256,7 @@ def test_expands_composite_recursively_preserving_structure():
         c_nested_expanded,
     )
 
-    context = cirq.TransformerContext(tags_to_ignore=["ignore"], deep=True)
+    context = cirq.TransformerContext(tags_to_ignore=("ignore",), deep=True)
     c_expanded = cirq.expand_composite(
         c_orig, no_decomp=lambda op: op.gate == cirq.CNOT, context=context
     )

cirq/transformers/gauge_compiling/__init__.py

@@ -42,3 +42,16 @@ from cirq.transformers.gauge_compiling.sqrt_iswap_gauge import (
 from cirq.transformers.gauge_compiling.cphase_gauge import (
     CPhaseGaugeTransformer as CPhaseGaugeTransformer,
 )
+
+
+from cirq.transformers.gauge_compiling.idle_moments_gauge import (
+    IdleMomentsGauge as IdleMomentsGauge,
+)
+
+from cirq.transformers.gauge_compiling.multi_moment_gauge_compiling import (
+    MultiMomentGaugeTransformer as MultiMomentGaugeTransformer,
+)
+
+from cirq.transformers.gauge_compiling.multi_moment_cphase_gauge import (
+    CPhaseGaugeTransformerMM as CPhaseGaugeTransformerMM,
+)

cirq/transformers/gauge_compiling/gauge_compiling.py

@@ -19,9 +19,10 @@ from __future__ import annotations
 import abc
 import functools
 import itertools
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 from numbers import Real
-from typing import Callable, Sequence, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -260,7 +261,7 @@ class GaugeTransformer:
         N: int,
         context: transformer_api.TransformerContext | None = None,
         prng: np.random.Generator | None = None,
-    ) -> tuple[circuits.AbstractCircuit, cirq.Sweepable]:
+    ) -> tuple[circuits.AbstractCircuit, cirq.Sweep]:
         """Generates a parameterized circuit with *N* sets of sweepable parameters.
 
         Args:

cirq/transformers/gauge_compiling/gauge_compiling_test.py

@@ -33,29 +33,31 @@ from cirq.transformers.gauge_compiling import (
 from cirq.transformers.gauge_compiling.sqrt_cz_gauge import SqrtCZGauge
 
 
-def test_deep_transformation_not_supported():
+def test_deep_transformation_not_supported() -> None:
+
+    empty_selector = GaugeSelector(gauges=())
 
     with pytest.raises(ValueError, match="cannot be used with deep=True"):
-        _ = GaugeTransformer(target=cirq.CZ, gauge_selector=lambda _: None)(
+        _ = GaugeTransformer(target=cirq.CZ, gauge_selector=empty_selector)(
             cirq.Circuit(), context=cirq.TransformerContext(deep=True)
         )
 
     with pytest.raises(ValueError, match="cannot be used with deep=True"):
-        _ = GaugeTransformer(target=cirq.CZ, gauge_selector=lambda _: None).as_sweep(
+        _ = GaugeTransformer(target=cirq.CZ, gauge_selector=empty_selector).as_sweep(
             cirq.Circuit(), context=cirq.TransformerContext(deep=True), N=1
         )
 
 
-def test_ignore_tags():
+def test_ignore_tags() -> None:
     c = cirq.Circuit(cirq.CZ(*cirq.LineQubit.range(2)).with_tags('foo'))
-    assert c == CZGaugeTransformer(c, context=cirq.TransformerContext(tags_to_ignore={"foo"}))
+    assert c == CZGaugeTransformer(c, context=cirq.TransformerContext(tags_to_ignore=("foo",)))
     parameterized_circuit, _ = CZGaugeTransformer.as_sweep(
-        c, context=cirq.TransformerContext(tags_to_ignore={"foo"}), N=1
+        c, context=cirq.TransformerContext(tags_to_ignore=("foo",)), N=1
     )
     assert c == parameterized_circuit
 
 
-def test_target_can_be_gateset():
+def test_target_can_be_gateset() -> None:
     qs = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.CZ(*qs))
     transformer = GaugeTransformer(
@@ -65,7 +67,7 @@ def test_target_can_be_gateset():
     assert transformer(c, prng=np.random.default_rng(0)) == want
 
 
-def test_as_sweep_multi_pre_or_multi_post():
+def test_as_sweep_multi_pre_or_multi_post() -> None:
     transformer = GaugeTransformer(
         target=cirq.CZ,
         gauge_selector=GaugeSelector(
@@ -91,7 +93,7 @@ def test_as_sweep_multi_pre_or_multi_post():
         )
 
 
-def test_as_sweep_invalid_gauge_sequence():
+def test_as_sweep_invalid_gauge_sequence() -> None:
     transfomer = GaugeTransformer(
         target=cirq.CZ,
         gauge_selector=GaugeSelector(
@@ -112,7 +114,7 @@ def test_as_sweep_invalid_gauge_sequence():
         transfomer.as_sweep(c, N=1)
 
 
-def test_as_sweep_convert_to_phxz_failed():
+def test_as_sweep_convert_to_phxz_failed() -> None:
     qs = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.CZ(*qs))
 
@@ -128,7 +130,7 @@ def test_as_sweep_convert_to_phxz_failed():
             _ = CZGaugeTransformer.as_sweep(c, context=cirq.TransformerContext(), N=1)
 
 
-def test_symbolize_2_qubits_gate_failed():
+def test_symbolize_2_qubits_gate_failed() -> None:
     qs = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.CZPowGate(exponent=0.5).on(*qs))
 
@@ -142,7 +144,7 @@ def test_symbolize_2_qubits_gate_failed():
             _ = SqrtCZGaugeTransformer.as_sweep(c, N=1)
 
 
-def test_symbolize_2_qubits_gate_failed_unmatched_symbol_length():
+def test_symbolize_2_qubits_gate_failed_unmatched_symbol_length() -> None:
     symbolizer = TwoQubitGateSymbolizer(symbolizer_fn=lambda gate, _: (gate, {}), n_symbols=2)
     with pytest.raises(ValueError, match="Expect 2 symbols, but got 1 symbols"):
         symbolizer(cirq.CZ, [sympy.Symbol('x')])

cirq/transformers/gauge_compiling/gauge_compiling_test_utils.py

@@ -33,7 +33,7 @@ class GaugeTester:
         ['generation_seed', 'transformation_seed'],
         np.random.RandomState(0).randint(2**31, size=(5, 2)).tolist(),
     )
-    def test_gauge_transformer(self, generation_seed, transformation_seed):
+    def test_gauge_transformer(self, generation_seed, transformation_seed) -> None:
         c = cirq.Circuit()
         while not any(op.gate == self.two_qubit_gate for op in c.all_operations()):
             c = cirq.testing.random_circuit(
@@ -57,7 +57,7 @@ class GaugeTester:
 
     @patch('cirq.transformers.gauge_compiling.gauge_compiling._select', autospec=True)
     @pytest.mark.parametrize('seed', range(5))
-    def test_all_gauges(self, mock_select, seed):
+    def test_all_gauges(self, mock_select, seed) -> None:
         assert isinstance(
             self.gauge_transformer.gauge_selector, GaugeSelector
         ), 'When using a custom selector, please override this method to properly test all gauges'
@@ -74,7 +74,7 @@ class GaugeTester:
             else:
                 _check_equivalent_with_error_message(c, nc, gauge)
 
-    def test_sweep(self):
+    def test_sweep(self) -> None:
         qubits = cirq.LineQubit.range(3)
 
         input_circuit = cirq.Circuit(