cirq-core 1.7.0.dev20250917002151__py3-none-any.whl → 1.7.0.dev20250918010530__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 11, 0):  # pragma: no cover
         'of Cirq (e.g. "python -m pip install cirq==1.5.0")'
     )
 
-__version__ = "1.7.0.dev20250917002151"
+__version__ = "1.7.0.dev20250918010530"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version() -> None:
-    assert cirq.__version__ == "1.7.0.dev20250917002151"
+    assert cirq.__version__ == "1.7.0.dev20250918010530"

cirq/ops/arithmetic_operation.py

@@ -130,9 +130,9 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
         1. The `apply` method is permitted to return values that have more bits
             than the registers they will be stored into. The extra bits are
             simply dropped. For example, if the value 5 is returned for a 2
-            qubit register then 5 % 2**2 = 1 will be used instead. Negative
+            qubit register then ``5 % 2**2 = 1`` will be used instead. Negative
             values are also permitted. For example, for a 3 qubit register the
-            value -2 becomes -2 % 2**3 = 6.
+            value -2 becomes ``-2 % 2**3 = 6``.
         2. When the value of the last `k` registers is not changed by the
             gate, the `apply` method is permitted to omit these values
             from the result. That is to say, when the length of the output is

cirq/ops/common_gates.py

@@ -391,7 +391,7 @@ class YPowGate(eigen_gate.EigenGate):
     Unlike `cirq.XPowGate` and `cirq.ZPowGate`, this gate has no generalization
     to qudits and hence does not take the dimension argument. Ignoring the
     global phase all generalized Pauli operators on a d-level system may be
-    written as X**a Z**b for a,b=0,1,...,d-1. For a qubit, there is only one
+    written as ``X**a Z**b`` for a,b=0,1,...,d-1. For a qubit, there is only one
     "mixed" operator: XZ, conventionally denoted -iY. However, when d > 2 there
     are (d-1)*(d-1) > 1 such "mixed" operators (still ignoring the global phase).
     Due to this ambiguity, qudit Y gate is not well defined. The "mixed" operators

cirq/ops/pauli_string_phasor.py

@@ -73,9 +73,9 @@ class PauliStringPhasor(gate_operation.GateOperation):
                 `pauli_string` are acted upon by identity. The order of
                 these qubits must match the order in `pauli_string`.
             exponent_neg: How much to phase vectors in the negative eigenspace,
-                in the form of the t in (-1)**t = exp(i pi t).
+                in the form of the t in ``(-1)**t = exp(i*pi*t)``.
             exponent_pos: How much to phase vectors in the positive eigenspace,
-                in the form of the t in (-1)**t = exp(i pi t).
+                in the form of the t in ``(-1)**t = exp(i*pi*t)``.
 
         Raises:
             ValueError: If coefficient is not 1 or -1 or the qubits of

cirq/transformers/gauge_compiling/__init__.py

@@ -42,3 +42,8 @@ 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,
+)

cirq/transformers/gauge_compiling/idle_moments_gauge.py

@@ -0,0 +1,222 @@
+# 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 functools
+from typing import Hashable, Iterator, Sequence, TYPE_CHECKING
+
+import attrs
+import numpy as np
+
+import cirq.circuits as circuits
+import cirq.ops as ops
+import cirq.protocols as protocols
+import cirq.transformers.transformer_api as transformer_api
+
+if TYPE_CHECKING:
+    import cirq
+
+_PAULIS: tuple[cirq.Gate, ...] = (ops.I, ops.X, ops.Y, ops.Z)  # type: ignore[has-type]
+_CLIFFORDS = tuple(ops.SingleQubitCliffordGate.all_single_qubit_cliffords)
+_INV_CLIFFORDS = tuple(c**-1 for c in ops.SingleQubitCliffordGate.all_single_qubit_cliffords)
+
+_NAME_TO_GATES = {'pauli': _PAULIS, 'clifford': _CLIFFORDS, 'inv_clifford': _INV_CLIFFORDS}
+
+
+def _gauges_arg_converter(gauges: str | Sequence[cirq.Gate] = 'clifford') -> tuple[cirq.Gate, ...]:
+    if isinstance(gauges, str):
+        if gauges not in _NAME_TO_GATES:
+            valid_names = tuple(_NAME_TO_GATES.keys())
+            raise ValueError(f"{gauges} is not a valid gauge name, valid names are {valid_names}")
+        return _NAME_TO_GATES[gauges]
+    return tuple(gauges)
+
+
+def _repr_fn(gauges: tuple[cirq.Gate, ...]) -> str:
+    if gauges is _PAULIS or gauges == _PAULIS:
+        return '"pauli"'
+    if gauges is _CLIFFORDS or gauges == _CLIFFORDS:
+        return '"clifford"'
+    if gauges is _INV_CLIFFORDS or gauges == _INV_CLIFFORDS:
+        return '"inv_clifford"'
+    return repr(gauges)
+
+
+def _get_structure(
+    active: list[tuple[int, bool]],
+    min_length: int,
+    n: int,
+    gauge_beginning: bool,
+    gauge_ending: bool,
+) -> Iterator[tuple[int, int]]:
+    if gauge_beginning:
+        stop, is_mergable = active[0]
+        if min_length <= stop:
+            if is_mergable:
+                yield (0, stop)
+            else:
+                yield (0, stop - 1)
+
+    for i in range(len(active) - 1):
+        left_pos, left_is_mergable = active[i]
+        right_pos, right_is_mergable = active[i + 1]
+        if right_pos - left_pos - 1 >= min_length:
+            yield (left_pos + 1 - left_is_mergable, right_pos - 1 + right_is_mergable)
+
+    if gauge_ending:
+        stop, is_mergable = active[-1]
+        if min_length <= n - stop - 1:
+            if is_mergable:
+                yield (stop, n - 1)
+            else:
+                yield (stop + 1, n - 1)
+
+
+def _merge(g1: cirq.Gate, g2: cirq.Gate, q: cirq.Qid, tags: Sequence[Hashable]) -> cirq.Operation:
+    u1 = protocols.unitary(g1)
+    u2 = protocols.unitary(g2)
+    return ops.PhasedXZGate.from_matrix(u2 @ u1)(q).with_tags(*tags)
+
+
+@transformer_api.transformer
+@attrs.frozen
+class IdleMomentsGauge:
+    r"""A transformer that inserts identity-preserving "gauge" gates around idle qubit moments.
+
+    This transformer identifies sequences of consecutive idle moments on a single qubit
+    that meet a `min_length` threshold. For each such sequence, it inserts a randomly
+    selected gate `G` from `gauges` at the start of the idle period and its inverse `G^-1`
+    at the end. This ensures the logical circuit behavior remains unchanged ($G \cdot G^{-1} = I$).
+
+    The primary goal is to introduce specific structure into idle periods, which is
+    useful for experiments.
+
+    Attributes:
+        min_length: Minimum number of consecutive idle moments for a gauge to be applied (>= 1).
+
+        gauges: A sequence of `cirq.Gate` objects to randomly select from.
+            Can be a custom tuple or a string alias:
+            - `"pauli"`: Uses single-qubit Pauli gates (I, X, Y, Z).
+            - `"clifford"`: Uses all 24 single-qubit Clifford gates.
+
+        gauge_beginning: If `True`, applies a gauge to idle moments at the circuit's start,
+            before any other qubit operation. Defaults to `False`.
+
+        gauge_ending: If `True`, applies a gauge to idle moments at the circuit's end,
+            after the last qubit operation. Defaults to `False`.
+    """
+
+    min_length: int = attrs.field(
+        validator=(attrs.validators.instance_of(int), attrs.validators.ge(1))
+    )
+    gauges: tuple[cirq.Gate, ...] = attrs.field(
+        default='clifford', converter=_gauges_arg_converter, repr=_repr_fn
+    )
+    gauge_beginning: bool = False
+    gauge_ending: bool = False
+
+    @functools.cached_property
+    def gauges_inverse(self) -> tuple[cirq.Gate, ...]:
+        if self.gauges is _PAULIS:
+            return _PAULIS
+        if self.gauges is _CLIFFORDS:
+            return _INV_CLIFFORDS
+        if self.gauges is _INV_CLIFFORDS:
+            return _CLIFFORDS
+        return tuple(g**-1 for g in self.gauges)
+
+    def __call__(
+        self,
+        circuit: cirq.AbstractCircuit,
+        *,
+        context: transformer_api.TransformerContext | None = None,
+        rng_or_seed: np.random.Generator | int | None = None,
+    ):
+        """Apply the IdleMomentGauge transformer.
+
+        Args:
+            circuit: The circuit to process.
+            context: The TransformerContext.
+            rng_or_seed: The source of randomness.
+
+        Returns:
+            A transformed circuit.
+
+        Raises:
+            ValueError: if the TransformerContext has deep=True.
+        """
+        rng = (
+            rng_or_seed
+            if isinstance(rng_or_seed, np.random.Generator)
+            else np.random.default_rng(rng_or_seed)
+        )
+        context = (
+            context
+            if isinstance(context, transformer_api.TransformerContext)
+            else transformer_api.TransformerContext(deep=False)
+        )
+        if context.deep:
+            raise ValueError("IdleMomentsGauge doesn't support deep TransformerContext")
+
+        tags_to_ignore = frozenset(context.tags_to_ignore)
+        all_qubits = circuit.all_qubits()
+
+        active_moments: dict[cirq.Qid, list[tuple[int, bool]]] = {q: [] for q in all_qubits}
+        for m_id, moment in enumerate(circuit):
+            if not tags_to_ignore.isdisjoint(moment.tags):
+                for q in all_qubits:
+                    active_moments[q].append((m_id, False))
+            else:
+                for op in moment:
+                    is_mergable = (
+                        len(op.qubits) == 1
+                        and tags_to_ignore.isdisjoint(op.tags)
+                        and op.gate is not None
+                    )
+                    for q in op.qubits:
+                        active_moments[q].append((m_id, is_mergable))
+
+        single_qubit_moments = [{q: op for op in m if len(op.qubits) == 1} for m in circuit]
+        non_single_qubit_moments = [[op for op in m if len(op.qubits) != 1] for m in circuit]
+
+        for q, active in active_moments.items():
+            for s, e in _get_structure(
+                active, self.min_length, len(circuit), self.gauge_beginning, self.gauge_ending
+            ):
+                gate_index = rng.choice(len(self.gauges))
+                gate = self.gauges[gate_index]
+                gate_inv = self.gauges_inverse[gate_index]
+
+                if existing_op := single_qubit_moments[s].get(q, None):
+                    existing_gate = existing_op.gate
+                    assert existing_gate is not None
+                    single_qubit_moments[s][q] = _merge(existing_gate, gate, q, existing_op.tags)
+                else:
+                    single_qubit_moments[s][q] = gate(q)
+
+                if existing_op := single_qubit_moments[e].get(q, None):
+                    existing_gate = existing_op.gate
+                    assert existing_gate is not None
+                    single_qubit_moments[e][q] = _merge(
+                        gate_inv, existing_gate, q, existing_op.tags
+                    )
+                else:
+                    single_qubit_moments[e][q] = gate_inv(q)
+
+        return circuits.Circuit.from_moments(
+            *(
+                [op for op in sq.values()] + nsq
+                for sq, nsq in zip(single_qubit_moments, non_single_qubit_moments, strict=True)
+            )
+        )

cirq/transformers/gauge_compiling/idle_moments_gauge_test.py

@@ -0,0 +1,193 @@
+# 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.
+
+
+import numpy as np
+import pytest
+
+import cirq
+from cirq.transformers import gauge_compiling
+
+
+class _MockRng(np.random.Generator):
+
+    def __init__(self, vals):
+        self._n_calls = 0
+        self._res = tuple(vals)
+
+    def choice(self, seq):
+        ret = self._res[self._n_calls]
+        self._n_calls += 1
+        return ret
+
+
+def test_add_gauge_merges_gates():
+    tr = gauge_compiling.IdleMomentsGauge(2, gauges='pauli')
+
+    circuit = cirq.Circuit.from_moments([], [], [], cirq.X(cirq.q(0)), [], [], cirq.X(cirq.q(0)))
+    transformed_circuit = tr(circuit, rng_or_seed=_MockRng([3]))
+
+    assert transformed_circuit == cirq.Circuit.from_moments(
+        [],
+        [],
+        [],
+        cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=1, z_exponent=0)(cirq.q(0)),
+        [],
+        [],
+        cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=1, z_exponent=0)(cirq.q(0)),
+    )
+
+
+def test_add_gauge_respects_ignore_tag():
+    tr = gauge_compiling.IdleMomentsGauge(2, gauges='pauli')
+
+    circuit = cirq.Circuit.from_moments(
+        cirq.X(cirq.q(0)), [], [], cirq.X(cirq.q(0)).with_tags('ignore')
+    )
+    transformed_circuit = tr(
+        circuit,
+        context=cirq.TransformerContext(tags_to_ignore=("ignore",)),
+        rng_or_seed=_MockRng([3]),
+    )
+    assert transformed_circuit == cirq.Circuit.from_moments(
+        cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=1, z_exponent=0)(cirq.q(0)),
+        [],
+        cirq.Z(cirq.q(0)),
+        cirq.X(cirq.q(0)).with_tags('ignore'),
+    )
+
+
+def test_add_gauge_respects_ignore_moment():
+    tr = gauge_compiling.IdleMomentsGauge(2, gauges='pauli')
+
+    circuit = cirq.Circuit.from_moments(
+        cirq.X(cirq.q(0)), [], [], cirq.Moment(cirq.X(cirq.q(0))).with_tags('ignore')
+    )
+    transformed_circuit = tr(
+        circuit,
+        context=cirq.TransformerContext(tags_to_ignore=("ignore",)),
+        rng_or_seed=_MockRng([3]),
+    )
+    assert transformed_circuit == cirq.Circuit.from_moments(
+        cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=1, z_exponent=0)(cirq.q(0)),
+        [],
+        cirq.Z(cirq.q(0)),
+        cirq.Moment(cirq.X(cirq.q(0))).with_tags('ignore'),
+    )
+
+
+def test_add_gauge_on_prefix():
+    tr = gauge_compiling.IdleMomentsGauge(3, gauges='clifford', gauge_beginning=True)
+
+    circuit = cirq.Circuit.from_moments([], [], [], cirq.CNOT(cirq.q(0), cirq.q(1)))
+    transformed_circuit = tr(circuit, rng_or_seed=_MockRng([20, 15]))
+    assert transformed_circuit == cirq.Circuit.from_moments(
+        [
+            cirq.SingleQubitCliffordGate.all_single_qubit_cliffords[20](cirq.q(0)),
+            cirq.SingleQubitCliffordGate.all_single_qubit_cliffords[15](cirq.q(1)),
+        ],
+        [],
+        [
+            cirq.SingleQubitCliffordGate.all_single_qubit_cliffords[20](cirq.q(0)) ** -1,
+            cirq.SingleQubitCliffordGate.all_single_qubit_cliffords[15](cirq.q(1)) ** -1,
+        ],
+        cirq.CNOT(cirq.q(0), cirq.q(1)),
+    )
+
+
+def test_add_gauge_on_prefix_with_merge():
+    tr = gauge_compiling.IdleMomentsGauge(3, gauges=[cirq.Y], gauge_beginning=True)
+
+    circuit = cirq.Circuit.from_moments([], [], [], cirq.X(cirq.q(0)))
+    transformed_circuit = tr(circuit, rng_or_seed=_MockRng([0]))
+    assert transformed_circuit == cirq.Circuit.from_moments(
+        [cirq.Y(cirq.q(0))],
+        [],
+        [],
+        cirq.PhasedXZGate(axis_phase_exponent=0, x_exponent=0, z_exponent=1)(cirq.q(0)),
+    )
+
+
+def test_add_gauge_on_suffix():
+    tr = gauge_compiling.IdleMomentsGauge(3, gauges='inv_clifford', gauge_ending=True)
+
+    circuit = cirq.Circuit.from_moments(cirq.CNOT(cirq.q(0), cirq.q(1)), [], [], [])
+    transformed_circuit = tr(circuit, rng_or_seed=_MockRng([20, 15]))
+    assert transformed_circuit == cirq.Circuit.from_moments(
+        cirq.CNOT(cirq.q(0), cirq.q(1)),
+        [
+            cirq.SingleQubitCliffordGate.all_single_qubit_cliffords[20](cirq.q(0)) ** -1,
+            cirq.SingleQubitCliffordGate.all_single_qubit_cliffords[15](cirq.q(1)) ** -1,
+        ],
+        [],
+        [
+            cirq.SingleQubitCliffordGate.all_single_qubit_cliffords[20](cirq.q(0)),
+            cirq.SingleQubitCliffordGate.all_single_qubit_cliffords[15](cirq.q(1)),
+        ],
+    )
+
+
+def test_add_gauge_on_suffix_with_merge():
+    tr = gauge_compiling.IdleMomentsGauge(3, gauges=[cirq.Y], gauge_ending=True)
+
+    circuit = cirq.Circuit.from_moments(cirq.X(cirq.q(0)), [], [], [])
+    transformed_circuit = tr(circuit, rng_or_seed=_MockRng([0]))
+    assert transformed_circuit == cirq.Circuit.from_moments(
+        cirq.PhasedXZGate(axis_phase_exponent=0, x_exponent=0, z_exponent=1)(cirq.q(0)),
+        [],
+        [],
+        cirq.Y(cirq.q(0)),
+    )
+
+
+def test_add_gauge_respects_min_length():
+    tr = gauge_compiling.IdleMomentsGauge(2, gauges=[cirq.X])
+
+    circuit = cirq.Circuit.from_moments(cirq.X(cirq.q(0)), [], cirq.X(cirq.q(0)))
+    transformed_circuit = tr(circuit)
+    assert transformed_circuit == circuit
+
+
+def test_context_with_deep_raises():
+    tr = gauge_compiling.IdleMomentsGauge(2, gauges=[cirq.X])
+
+    circuit = cirq.Circuit.from_moments(cirq.X(cirq.q(0)), [], cirq.X(cirq.q(0)))
+    with pytest.raises(
+        ValueError, match="IdleMomentsGauge doesn't support deep TransformerContext"
+    ):
+        _ = tr(circuit, context=cirq.TransformerContext(deep=True))
+
+
+def test_gauge_with_invalid_name_raises():
+    with pytest.raises(ValueError, match='valid gauge'):
+        _ = gauge_compiling.IdleMomentsGauge(2, gauges='invalid')
+
+
+def test_repr():
+    assert repr(gauge_compiling.IdleMomentsGauge(3, gauges='pauli')) == (
+        'IdleMomentsGauge(min_length=3, gauges="pauli", '
+        'gauge_beginning=False, gauge_ending=False)'
+    )
+    assert repr(gauge_compiling.IdleMomentsGauge(4, gauges='clifford')) == (
+        'IdleMomentsGauge(min_length=4, gauges="clifford", '
+        'gauge_beginning=False, gauge_ending=False)'
+    )
+    assert repr(gauge_compiling.IdleMomentsGauge(5, gauges='inv_clifford')) == (
+        'IdleMomentsGauge(min_length=5, gauges="inv_clifford", '
+        'gauge_beginning=False, gauge_ending=False)'
+    )
+    assert repr(gauge_compiling.IdleMomentsGauge(6, gauges=[cirq.X])) == (
+        'IdleMomentsGauge(min_length=6, gauges=(cirq.X,), '
+        'gauge_beginning=False, gauge_ending=False)'
+    )

{cirq_core-1.7.0.dev20250917002151.dist-info → cirq_core-1.7.0.dev20250918010530.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cirq-core
-Version: 1.7.0.dev20250917002151
+Version: 1.7.0.dev20250918010530
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers

{cirq_core-1.7.0.dev20250917002151.dist-info → cirq_core-1.7.0.dev20250918010530.dist-info}/RECORD

@@ -4,8 +4,8 @@ cirq/_compat_test.py,sha256=emXpdD5ZvwLRlFAoQB8YatmZyU3b4e9jg6FppMTUhkU,33900
 cirq/_doc.py,sha256=BrnoABo1hk5RgB3Cgww4zLHUfiyFny0F1V-tOMCbdaU,2909
 cirq/_import.py,sha256=ixBu4EyGl46Ram2cP3p5eZVEFDW5L2DS-VyTjz4N9iw,8429
 cirq/_import_test.py,sha256=oF4izzOVZLc7NZ0aZHFcGv-r01eiFFt_JORx_x7_D4s,1089
-cirq/_version.py,sha256=EsoWF8NKNSNvD35WOCxHTTckzZxg3IczSaTfYLaJy7I,1206
-cirq/_version_test.py,sha256=jRCns8RCs4dkVcjvk3UhhbeJ7lk7P3dmMuwwjmzkZbA,155
+cirq/_version.py,sha256=qT1RStwGY0KBEfFwGI71xBA4r4MDbW-y_k8XQxAk52M,1206
+cirq/_version_test.py,sha256=hOFVodx_1T4vsd1L4mB_loNGQ0uc2S_gIFDrK_sPpgw,155
 cirq/conftest.py,sha256=wSDKNdIQRDfLnXvOCWD3erheOw8JHRhdfQ53EyTUIXg,1239
 cirq/json_resolver_cache.py,sha256=A5DIgFAY1hUNt9vai_C3-gGBv24116CJMzQxMcXOax4,13726
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -283,7 +283,7 @@ cirq/neutral_atoms/convert_to_neutral_atom_gates.py,sha256=2sIJd5CzWjehMi_rfFW8Q
 cirq/neutral_atoms/convert_to_neutral_atom_gates_test.py,sha256=fhCJubuFa81aRwd__sgBLc7D2z5VnwfzH-0lZvEv6jo,1905
 cirq/neutral_atoms/neutral_atom_devices.py,sha256=9GP2IsrivvAoqnoEe-jkZ4Ef7v-zylwAr7jlAFkdEIo,1409
 cirq/ops/__init__.py,sha256=HNtQJBFeiJJ-MbbNqe3f6KfcmZ_4YP5oTcCcZnGkYbY,8318
-cirq/ops/arithmetic_operation.py,sha256=cokwokyzKa3zJkyxopP81fTRMutHfI277ZObKw9El_w,10022
+cirq/ops/arithmetic_operation.py,sha256=DSUd48680C6hBELJoNRUUuFvVxSO2ZAF_o1ZmtUcKNo,10030
 cirq/ops/arithmetic_operation_test.py,sha256=F5fPQF_sRWi8qyP_SgDzJ8kfX0jUVMj59_VOPpbXH_0,4938
 cirq/ops/boolean_hamiltonian.py,sha256=x25fraM9NNs-XzDKDl2AZ1AMpkVovfe-dNm_0wOolyI,14927
 cirq/ops/boolean_hamiltonian_test.py,sha256=_4mFFrbO9C21oZYutr_pl01_bqDDxvgY_h4DWKGkse0,8630
@@ -295,7 +295,7 @@ cirq/ops/common_channels.py,sha256=ZZa2JCyPtrKfGhcAGCUUzA4qym8S9isKs-xs-TEkhKs,3
 cirq/ops/common_channels_test.py,sha256=dPveO6j3qxmdRXaQhEIvj5vKRE0v3pQ9ICmjnSSbP0Q,30761
 cirq/ops/common_gate_families.py,sha256=trK4ZXCKqYahZkyuwaAn-TcjUu7gmI9n9geO8PYiRGE,8606
 cirq/ops/common_gate_families_test.py,sha256=SfIKolQhVIof0uOHljY1QKT9Tu_4WzUsoeCNR2jIOPg,5441
-cirq/ops/common_gates.py,sha256=luEk507wQgstyl15DUq0AtKsXYnJqX0Xei4hM5RFjaY,58239
+cirq/ops/common_gates.py,sha256=P8S_2IfKiLCY2npBgDqlQLYmnkdzxiPBeO53htV9xGQ,58243
 cirq/ops/common_gates_test.py,sha256=IcUWxDTTTbis0efXz2Kn0zAdclp9R31fZAfCx3E-BOo,49758
 cirq/ops/control_values.py,sha256=GrNi8YJZSZDCl8Su6Ocimvd1R1SejFJjVu2thcJ8VLI,13346
 cirq/ops/control_values_test.py,sha256=Wyn0nwtcpnJvcPVRHmFGb3PtYxvsbpluA5UbPrG7tIo,13067
@@ -352,7 +352,7 @@ cirq/ops/pauli_interaction_gate_test.py,sha256=9IGQjf4cRNe1EAsxVJjTMysoO2TxUhDlp
 cirq/ops/pauli_measurement_gate.py,sha256=OzbQeMzr9cHQsai8K-usg3Il74o8gdXZLksLuYr8RcU,7113
 cirq/ops/pauli_measurement_gate_test.py,sha256=IDnbQgyaj-nbYw_sslPBccl8aRGTlMrADc_EEiAvluk,6929
 cirq/ops/pauli_string.py,sha256=C6QlWKHRCqAoN5DNfUsnOw1i4oJnyc_c878GtiZnDfk,63356
-cirq/ops/pauli_string_phasor.py,sha256=5Tm_OoR_v44Kb3AQAw5XIxpcmKtompdbq5ZefYGEUmk,18207
+cirq/ops/pauli_string_phasor.py,sha256=Q67QikobiE5A9wGaa6azLsNNMJqfxmKKOV3XRJHjVkk,18215
 cirq/ops/pauli_string_phasor_test.py,sha256=ZIoraHH3kOFjtEfThXDS-sxUvSU8MYZ2avtdiPcyN6w,28309
 cirq/ops/pauli_string_raw_types.py,sha256=mBOAwfBT_y7yiSyC6Hr-ofLyIkjyOH5urmK-gitD3-Y,2226
 cirq/ops/pauli_string_raw_types_test.py,sha256=ZcOZ31KSVIc7ReZoO8WZEX8MOyPOhUWaYLppvGTE4-8,2761
@@ -1134,7 +1134,7 @@ cirq/transformers/analytical_decompositions/two_qubit_to_ms.py,sha256=dP9umZJBgN
 cirq/transformers/analytical_decompositions/two_qubit_to_ms_test.py,sha256=Cj_GZvJykt5NfNuB8vEY30DE2tU3nJtnUztAArgnfE4,4204
 cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap.py,sha256=s08m1PJODNUNzNNkn_zu2qasRSWmXJAq8Tb9cHKk-yU,25348
 cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap_test.py,sha256=WfPQA_wTpRknovNenxC1LPAt9cVHqwdRhUhPZ8sLNr0,20655
-cirq/transformers/gauge_compiling/__init__.py,sha256=kgsBfsjwCjHMcwZd2wpzXFWPT9ZK-7PjzhEMV0q0pao,1557
+cirq/transformers/gauge_compiling/__init__.py,sha256=T1IaBKgf2GgVbozsHun7lJhdypasX9olQVh9eYhY7gk,1670
 cirq/transformers/gauge_compiling/cphase_gauge.py,sha256=EoM_TKZt8mJwYFQAfv3rviitXWvGT8I5N36droPWPCE,5576
 cirq/transformers/gauge_compiling/cphase_gauge_test.py,sha256=dPV2vqsyC-eUi_jmwEk6dhOKHnQLJ_A01_Emxw2j8QQ,1427
 cirq/transformers/gauge_compiling/cz_gauge.py,sha256=dtcC49-qIvH_hRaQpQLBvGu-3323r4cwWpFImBnDebE,2586
@@ -1143,6 +1143,8 @@ cirq/transformers/gauge_compiling/gauge_compiling.py,sha256=bXqAEVBXHplnxRMwNA0G
 cirq/transformers/gauge_compiling/gauge_compiling_test.py,sha256=JFG7aCe-PxPGZDPCAx82ILu6PX_laFvCDlaabwvL0Kc,5272
 cirq/transformers/gauge_compiling/gauge_compiling_test_utils.py,sha256=NUbcz-tGS58QPohpsmMx0RbB4d79GMSoyVxdL3CPiZc,5060
 cirq/transformers/gauge_compiling/gauge_compiling_test_utils_test.py,sha256=qPcs2BWU-1gOEz0NCLixBLO9I1PVIOLShB7wkprcQZY,1896
+cirq/transformers/gauge_compiling/idle_moments_gauge.py,sha256=t5vCp4iLA8Wcx7p81S_4JPhk3TaHCTNQGuvooPDF-gQ,8458
+cirq/transformers/gauge_compiling/idle_moments_gauge_test.py,sha256=OSb0840o0M8Qpde_Dp3-sRCGrJCO4rBgArDLnnT8D-g,6903
 cirq/transformers/gauge_compiling/iswap_gauge.py,sha256=CfW3hgO6AgUB7D6tC8J2XZQw2Ge77LT44BygCzMW4Xc,3536
 cirq/transformers/gauge_compiling/iswap_gauge_test.py,sha256=V6g-jyGujMKEzGtOi_OhMxX5oTznGXJi9tCNKI9Qrb8,901
 cirq/transformers/gauge_compiling/spin_inversion_gauge.py,sha256=yhrF4pa1u0-iwYay47_2bZ4xfU323TOdlyazl0U9v4c,1122
@@ -1234,8 +1236,8 @@ cirq/work/sampler.py,sha256=rxbMWvrhu3gfNSBjZKozw28lLKVvBAS_1EGyPdYe8Xg,19041
 cirq/work/sampler_test.py,sha256=SsMrRvLDYELyOAWLKISjkdEfrBwLYWRsT6D8WrsLM3Q,13533
 cirq/work/zeros_sampler.py,sha256=Fs2JWwq0n9zv7_G5Rm-9vPeHUag7uctcMOHg0JTkZpc,2371
 cirq/work/zeros_sampler_test.py,sha256=lQLgQDGBLtfImryys2HzQ2jOSGxHgc7-koVBUhv8qYk,3345
-cirq_core-1.7.0.dev20250917002151.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.7.0.dev20250917002151.dist-info/METADATA,sha256=FqxIlIRzJo7zx73HMtZSJ9QG5HNJYfU4M7VKx2dG3t8,4758
-cirq_core-1.7.0.dev20250917002151.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cirq_core-1.7.0.dev20250917002151.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.7.0.dev20250917002151.dist-info/RECORD,,
+cirq_core-1.7.0.dev20250918010530.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.7.0.dev20250918010530.dist-info/METADATA,sha256=-ZoH2EPBg9AoDgA24AiwcKOi7XcY7cV_trzBDomt5qE,4758
+cirq_core-1.7.0.dev20250918010530.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cirq_core-1.7.0.dev20250918010530.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.7.0.dev20250918010530.dist-info/RECORD,,