cirq-core 1.7.0.dev20251027223253__py3-none-any.whl → 1.7.0.dev20251028035559__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.dev20251027223253"
+__version__ = "1.7.0.dev20251028035559"

cirq/_version_test.py

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

cirq/transformers/dynamical_decoupling.py

@@ -16,11 +16,13 @@
 
 from __future__ import annotations
 
+from enum import Enum
 from functools import reduce
 from itertools import cycle
 from typing import TYPE_CHECKING
 
 import numpy as np
+from attrs import frozen
 
 from cirq import ops, protocols
 from cirq.circuits import Circuit, FrozenCircuit, Moment
@@ -133,10 +135,6 @@ def _calc_busy_moment_range_of_each_qubit(circuit: FrozenCircuit) -> dict[ops.Qi
     return busy_moment_range_by_qubit
 
 
-def _is_insertable_moment(moment: Moment, single_qubit_gate_moments_only: bool) -> bool:
-    return not single_qubit_gate_moments_only or _is_single_qubit_gate_moment(moment)
-
-
 def _merge_single_qubit_ops_to_phxz(
     q: ops.Qid, operations: tuple[ops.Operation, ...]
 ) -> ops.Operation:
@@ -149,34 +147,162 @@ def _merge_single_qubit_ops_to_phxz(
     return gate.on(q)
 
 
-def _calc_pulled_through(moment: Moment, input_pauli_ops: ops.PauliString) -> ops.PauliString:
-    """Calculates the pulled_through such that circuit(input_pauli_ops, moment.clifford_ops) is
-    equivalent to circuit(moment.clifford_ops, pulled_through).
+def _backward_set_stopping_slots(
+    q: ops.Qid,
+    from_mid: int,
+    mergable: dict[ops.Qid, dict[int, bool]],
+    need_to_stop: dict[ops.Qid, dict[int, bool]],
+    gate_types: dict[ops.Qid, dict[int, _CellType]],
+    circuit: FrozenCircuit,
+):
+    """Sets stopping slots for dynamical decoupling insertion.
+
+    This function traverses backward from a given moment `from_mid` for a specific qubit `q`.
+    It identifies moments where a dynamical decoupling sequence needs to be "stopped".
+
+    Args:
+        q: The qubit for which to set stopping slots.
+        from_mid: The moment ID to start the backward traversal from.
+        mergable: A dictionary indicating if a single-qubit Clifford gate at (qubit, moment_id)
+            can be merged with a Pauli gate.
+        need_to_stop: A dictionary to mark moments where a DD sequence must be stopped.
+        gate_types: A dictionary indicating the type of gate at each (qubit, moment_id).
+        circuit: The original frozen circuit.
     """
-    clifford_ops_in_moment: list[ops.Operation] = [
-        op for op in moment.operations if _is_clifford_op(op)
-    ]
-    return input_pauli_ops.after(clifford_ops_in_moment)
+    affected_qubits: set[ops.Qid] = {q}
+    for back_mid in range(from_mid, -1, -1):
+        for back_q in set(affected_qubits):
+            if gate_types[back_q][back_mid] == _CellType.WALL:
+                affected_qubits.remove(back_q)
+                continue
+            if mergable[back_q][back_mid]:
+                need_to_stop[back_q][back_mid] = True
+                affected_qubits.remove(back_q)
+                continue
+            op_at_q = circuit[back_mid].operation_at(back_q) or ops.I(q)
+            affected_qubits.update(op_at_q.qubits)
+        if not affected_qubits:
+            break
+
+
+class _CellType(Enum):
+    UNKNOWN = '?'
+    # Non-insertable gates that cannot be pulled through
+    WALL = 'w'
+    # Clifford gates where Pauli Gates can be pulled through
+    DOOR = 'd'
+    # An empty gate can be used to insert Pauli gates from the dd sequence
+    INSERTABLE = 'i'
+
+
+@frozen
+class _Grid:
+    """A grid representation of the circuit where each gate position is labeled for
+      dynamical decoupling.
+
+    With this representation, a DD sequence can be automatically navigated in a
+    forward-only process. This avoids issues where a partially inserted DD
+    sequence encounters a "wall" and a new moment must be inserted because the
+    remaining DD sequence cannot be absorbed by nearby gates.
+
+    This labeled representation pre-calculates where DD pulses can be inserted
+    and where leftover DD sequences must be merged, avoiding the need for
+    backtracking.
+
+    An example labeled circuit is shown below:
+         |  0  |  1  |  2  |  3  |  4  |
+    -----+-----+-----+-----+-----+-----+
+    q(0) |  d  |  i  | i,s |  d  |  w  |
+    q(1) |  d  |  i  | d,s |  w  |  w  |
+    q(2) |  d  |  d  | d,s |  w  |  w  |
+    where `w`=WALL, `d`=DOOR, `i`=INSERTABLE. `s` represents a stop gate,
+    meaning that any unfinished DD sequences must be merged at this gate.
+    """
+
+    gate_types: dict[ops.Qid, dict[int, _CellType]]
+    need_to_stop: dict[ops.Qid, dict[int, bool]]
+    circuit: FrozenCircuit
+
+    @classmethod
+    def from_circuit(
+        cls, circuit: cirq.FrozenCircuit, single_qubit_gate_moments_only: bool
+    ) -> _Grid:
+        gate_types: dict[ops.Qid, dict[int, _CellType]] = {
+            q: {mid: _CellType.UNKNOWN for mid in range(len(circuit))} for q in circuit.all_qubits()
+        }
+        mergable: dict[ops.Qid, dict[int, bool]] = {
+            q: {mid: False for mid in range(len(circuit))} for q in circuit.all_qubits()
+        }
+        busy_moment_range_by_qubit = _calc_busy_moment_range_of_each_qubit(circuit)
+
+        # Set gate types for each (q, mid)
+        for mid, moment in enumerate(circuit):
+            is_insertable_moment = (
+                not single_qubit_gate_moments_only or _is_single_qubit_gate_moment(moment)
+            )
+            for q in circuit.all_qubits():
+                if mid < busy_moment_range_by_qubit[q][0] or mid > busy_moment_range_by_qubit[q][1]:
+                    gate_types[q][mid] = _CellType.WALL
+                    continue
+                op_at_q = moment.operation_at(q)
+                if op_at_q is None:
+                    if is_insertable_moment:
+                        gate_types[q][mid] = _CellType.INSERTABLE
+                        mergable[q][mid] = True
+                    else:
+                        gate_types[q][mid] = _CellType.DOOR
+                else:
+                    if _is_clifford_op(op_at_q):
+                        gate_types[q][mid] = _CellType.DOOR
+                        mergable[q][mid] = _is_single_qubit_operation(op_at_q)
+                    else:
+                        gate_types[q][mid] = _CellType.WALL
+
+        need_to_stop: dict[ops.Qid, dict[int, bool]] = {
+            q: {mid: False for mid in range(len(circuit))} for q in circuit.all_qubits()
+        }
+        # Reversely find the last mergeable gate of each qubit, set them as need_to_stop.
+        for q in circuit.all_qubits():
+            _backward_set_stopping_slots(
+                q, len(circuit) - 1, mergable, need_to_stop, gate_types, circuit
+            )
+        # Reversely check for each wall gate, mark the closest mergeable gate as need_to_stop.
+        for mid in range(len(circuit)):
+            for q in circuit.all_qubits():
+                if gate_types[q][mid] == _CellType.WALL:
+                    _backward_set_stopping_slots(
+                        q, mid - 1, mergable, need_to_stop, gate_types, circuit
+                    )
+        return cls(circuit=circuit, gate_types=gate_types, need_to_stop=need_to_stop)
 
+    def __str__(self) -> str:
+        if not self.gate_types:
+            return "Grid(empty)"
 
-def _get_stop_qubits(moment: Moment) -> set[ops.Qid]:
-    stop_pulling_through_qubits: set[ops.Qid] = set()
-    for op in moment:
-        if (not _is_clifford_op(op) and not _is_single_qubit_operation(op)) or not has_unitary(
-            op
-        ):  # multi-qubit clifford op or non-mergable op.
-            stop_pulling_through_qubits.update(op.qubits)
-    return stop_pulling_through_qubits
+        qubits = sorted(list(self.gate_types.keys()))
+        num_moments = len(self.gate_types[qubits[0]])
 
+        max_qubit_len = max(len(str(q)) for q in qubits) if qubits else 0
 
-def _need_merge_pulled_through(op_at_q: ops.Operation, is_at_last_busy_moment: bool) -> bool:
-    """With a pulling through pauli gate before op_at_q, need to merge with the
-    pauli in the conditions below."""
-    # The op must be mergable and single-qubit
-    if not (_is_single_qubit_operation(op_at_q) and has_unitary(op_at_q)):
-        return False
-    # Either non-Clifford or at the last busy moment
-    return is_at_last_busy_moment or not _is_clifford_op(op_at_q)
+        header = f"{'':>{max_qubit_len}} |"
+        for i in range(num_moments):
+            header += f" {i:^3} |"
+
+        separator = f"{'-' * max_qubit_len}-+"
+        separator += '-----+' * num_moments
+
+        lines = ["Grid Repr:", header, separator]
+
+        for q in qubits:
+            row_str = f"{str(q):>{max_qubit_len}} |"
+            for mid in range(num_moments):
+                gate_type = self.gate_types[q][mid].value
+                stop = self.need_to_stop[q][mid]
+                cell = f"{gate_type},s" if stop else f" {gate_type} "
+                row_str += f" {cell} |"
+            lines.append(row_str)
+
+        return "\n".join(lines)
 
 
 @transformer_api.transformer
@@ -188,7 +314,7 @@ def add_dynamical_decoupling(
     single_qubit_gate_moments_only: bool = True,
 ) -> cirq.Circuit:
     """Adds dynamical decoupling gate operations to a given circuit.
-    This transformer might add new moments and thus change the structure of the original circuit.
+    This transformer preserves the structure of the original circuit.
 
     Args:
           circuit: Input circuit to transform.
@@ -202,11 +328,18 @@ def add_dynamical_decoupling(
     Returns:
           A copy of the input circuit with dynamical decoupling operations.
     """
-    base_dd_sequence, pauli_map = _parse_dd_sequence(schema)
+
+    if context is not None and context.deep:
+        raise ValueError("Deep transformation is not supported.")
+
     orig_circuit = circuit.freeze()
 
-    busy_moment_range_by_qubit = _calc_busy_moment_range_of_each_qubit(orig_circuit)
+    grid = _Grid.from_circuit(orig_circuit, single_qubit_gate_moments_only)
+
+    if context is not None and context.logger is not None:
+        context.logger.log("Preprocessed input circuit grid repr:\n%s", str(grid))
 
+    base_dd_sequence, pauli_map = _parse_dd_sequence(schema)
     # Stores all the moments of the output circuit chronologically.
     transformed_moments: list[Moment] = []
     # A PauliString stores the result of 'pulling' Pauli gates past each operations
@@ -215,90 +348,30 @@ def add_dynamical_decoupling(
     # Iterator of gate to be used in dd sequence for each qubit.
     dd_iter_by_qubits = {q: cycle(base_dd_sequence) for q in circuit.all_qubits()}
 
-    def _update_pulled_through(q: ops.Qid, insert_gate: ops.Gate) -> ops.Operation:
-        nonlocal pulled_through, pauli_map
-        pulled_through *= pauli_map[insert_gate].on(q)
-        return insert_gate.on(q)
-
-    # Insert and pull remaining Pauli ops through the whole circuit.
-    # General ideas are
-    #   * Pull through Clifford gates.
-    #   * Stop at multi-qubit non-Clifford ops (and other non-mergable ops).
-    #   * Merge to single-qubit non-Clifford ops.
-    #   * Insert a new moment if necessary.
-    # After pulling through pulled_through at `moment`, we expect a transformation of
-    #  (pulled_through, moment) -> (updated_moment, updated_pulled_through) or
-    #  (pulled_through, moment) -> (new_moment, updated_moment, updated_pulled_through)
-    # Moments structure changes are split into 3 steps:
-    #   1, (..., last_moment, pulled_through1, moment, ...)
-    #        -> (..., last_moment, new_moment or None, pulled_through2, moment, ...)
-    #   2, (..., pulled_through2, moment, ...)  -> (..., pulled_through3, updated_moment, ...)
-    #   3, (..., pulled_through3, updated_moment, ...)
-    #        -> (..., updated_moment, pulled_through4, ...)
     for moment_id, moment in enumerate(orig_circuit.moments):
-        # Step 1, insert new_moment if necessary.
-        # In detail: stop pulling through for multi-qubit non-Clifford ops or gates without
-        # unitary representation (e.g., measure gates). If there are remaining pulled through ops,
-        # insert into a new moment before current moment.
-        stop_pulling_through_qubits: set[ops.Qid] = _get_stop_qubits(moment)
-        new_moment_ops: list[ops.Operation] = []
-        for q in stop_pulling_through_qubits:
-            # Insert the remaining pulled_through
-            remaining_pulled_through_gate = pulled_through.get(q)
-            if remaining_pulled_through_gate is not None:
-                new_moment_ops.append(_update_pulled_through(q, remaining_pulled_through_gate))
-            # Reset dd sequence
-            dd_iter_by_qubits[q] = cycle(base_dd_sequence)
-        # Need to insert a new moment before current moment
-        if new_moment_ops:
-            # Fill insertable idle moments in the new moment using dd sequence
-            for q in orig_circuit.all_qubits() - stop_pulling_through_qubits:
-                if busy_moment_range_by_qubit[q][0] < moment_id <= busy_moment_range_by_qubit[q][1]:
-                    new_moment_ops.append(_update_pulled_through(q, next(dd_iter_by_qubits[q])))
-            transformed_moments.append(Moment(new_moment_ops))
-
-        # Step 2, calc updated_moment with insertions / merges.
         updated_moment_ops: set[cirq.Operation] = set()
         for q in orig_circuit.all_qubits():
-            op_at_q = moment.operation_at(q)
-            remaining_pulled_through_gate = pulled_through.get(q)
-            updated_op = op_at_q
-            if op_at_q is None:  # insert into idle op
-                if not _is_insertable_moment(moment, single_qubit_gate_moments_only):
-                    continue
-                if (
-                    busy_moment_range_by_qubit[q][0] < moment_id < busy_moment_range_by_qubit[q][1]
-                ):  # insert next pauli gate in the dd sequence
-                    updated_op = _update_pulled_through(q, next(dd_iter_by_qubits[q]))
-                elif (  # insert the remaining pulled through if beyond the ending busy moment
-                    moment_id > busy_moment_range_by_qubit[q][1]
-                    and remaining_pulled_through_gate is not None
-                ):
-                    updated_op = _update_pulled_through(q, remaining_pulled_through_gate)
-            elif (
-                remaining_pulled_through_gate is not None
-            ):  # merge pulled-through of q to op_at_q if needed
-                if _need_merge_pulled_through(
-                    op_at_q, moment_id == busy_moment_range_by_qubit[q][1]
-                ):
-                    remaining_op = _update_pulled_through(q, remaining_pulled_through_gate)
-                    updated_op = _merge_single_qubit_ops_to_phxz(q, (remaining_op, op_at_q))
-            if updated_op is not None:
-                updated_moment_ops.add(updated_op)
-
-        if updated_moment_ops:
-            updated_moment = Moment(updated_moment_ops)
-            transformed_moments.append(updated_moment)
-
-            # Step 3, update pulled through.
-            # In detail: pulling current `pulled_through` through updated_moment.
-            pulled_through = _calc_pulled_through(updated_moment, pulled_through)
-
-    # Insert a new moment if there are remaining pulled-through operations.
-    ending_moment_ops = []
-    for affected_q, combined_op_in_pauli in pulled_through.items():
-        ending_moment_ops.append(combined_op_in_pauli.on(affected_q))
-    if ending_moment_ops:
-        transformed_moments.append(Moment(ending_moment_ops))
+            new_op_at_q = moment.operation_at(q)
+            if grid.gate_types[q][moment_id] == _CellType.INSERTABLE:
+                new_gate = next(dd_iter_by_qubits[q])
+                new_op_at_q = new_gate.on(q)
+                pulled_through *= pauli_map[new_gate].on(q)
+            if grid.need_to_stop[q][moment_id]:
+                to_be_merged = pulled_through.get(q)
+                if to_be_merged is not None:
+                    new_op_at_q = _merge_single_qubit_ops_to_phxz(
+                        q, (to_be_merged.on(q), new_op_at_q or ops.I(q))
+                    )
+                    pulled_through *= to_be_merged.on(q)
+            if new_op_at_q is not None:
+                updated_moment_ops.add(new_op_at_q)
+
+        updated_moment = Moment(updated_moment_ops)
+        clifford_ops = [op for op in updated_moment if _is_clifford_op(op)]
+        pulled_through = pulled_through.after(clifford_ops)
+        transformed_moments.append(updated_moment)
+
+    if len(pulled_through) > 0:
+        raise RuntimeError("Expect empty remaining Paulis after the dd insertion.")
 
     return Circuit.from_moments(*transformed_moments)

cirq/transformers/dynamical_decoupling_test.py

@@ -15,12 +15,14 @@
 from __future__ import annotations
 
 from typing import Sequence
+from unittest import mock
 
 import numpy as np
 import pytest
 
 import cirq
 from cirq import add_dynamical_decoupling, CNOT, CZ, CZPowGate, H, X, Y, Z
+from cirq.transformers.dynamical_decoupling import _CellType, _Grid
 
 
 def assert_sim_eq(circuit1: cirq.AbstractCircuit, circuit2: cirq.AbstractCircuit) -> None:
@@ -163,10 +165,6 @@ def test_pull_through_h_gate_case1(single_qubit_gate_moments_only: bool) -> None
     a: ───H───────H───────@───
                           │
     b: ───H───H───H───H───X───
-    Output:
-    a: ───H───X───H───X───@───Y───
-                          │
-    b: ───H───H───H───H───X───X───
     """
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
@@ -179,14 +177,11 @@ def test_pull_through_h_gate_case1(single_qubit_gate_moments_only: bool) -> None
             cirq.Moment(H(b)),
             cirq.Moment(CNOT(a, b)),
         ),
-        expected_circuit=cirq.Circuit(
-            cirq.Moment(H(a), H(b)),
-            cirq.Moment(H(b), X(a)),
-            cirq.Moment(H(a), H(b)),
-            cirq.Moment(H(b), X(a)),
-            cirq.Moment(CNOT(a, b)),
-            cirq.Moment(Y(a), X(b)),
-        ),
+        expected_circuit="""
+a: ───H───X───H───PhXZ(a=-0.5,x=0,z=-1)───@───
+                                          │
+b: ───H───H───H───H───────────────────────X───
+""",
         schema="XX_PAIR",
         single_qubit_gate_moments_only=single_qubit_gate_moments_only,
     )
@@ -199,10 +194,6 @@ def test_pull_through_h_gate_case2(single_qubit_gate_moments_only: bool) -> None
     a: ───H───────H───────H───
 
     b: ───H───H───H───H───H───
-    Output:
-    a: ───H───X───H───X───PhXZ(a=0.5,x=0.5,z=1)───
-
-    b: ───H───H───H───H───H───────────────────────
     """
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
@@ -215,15 +206,11 @@ def test_pull_through_h_gate_case2(single_qubit_gate_moments_only: bool) -> None
             cirq.Moment(H(b)),
             cirq.Moment(H(a), H(b)),
         ),
-        expected_circuit=cirq.Circuit(
-            cirq.Moment(H(a), H(b)),
-            cirq.Moment(H(b), X(a)),
-            cirq.Moment(H(a), H(b)),
-            cirq.Moment(H(b), X(a)),
-            cirq.Moment(
-                cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=0.5, z_exponent=1).on(a), H(b)
-            ),
-        ),
+        expected_circuit="""
+a: ───H───X───H───X───PhXZ(a=0.5,x=0.5,z=-1)───
+
+b: ───H───H───H───H───H────────────────────────
+""",
         schema="XX_PAIR",
         single_qubit_gate_moments_only=single_qubit_gate_moments_only,
     )
@@ -444,24 +431,6 @@ def test_scattered_circuit2() -> None:
     7: ───────────────@───@───
                           │
     8: ───────────────────@───
-    Output:
-    0: ───────────────────@───
-                          │
-    1: ───────────────@───@───
-                      │
-    2: ───────────@───@───────
-                  │
-    3: ───────@───@───────────
-              │
-    4: ───@───@───────────────
-          │
-    5: ───@───X───@───X───────
-                  │
-    6: ───────────@───@───Z───
-                      │
-    7: ───────────────@───@───
-                          │
-    8: ───────────────────@───
     """
     qubits = cirq.LineQubit.range(9)
     assert_dd(
@@ -472,13 +441,25 @@ def test_scattered_circuit2() -> None:
             cirq.Moment(CZ(*qubits[1:3]), CZ(*qubits[6:8])),
             cirq.Moment(CZ(*qubits[0:2]), CZ(*qubits[7:])),
         ),
-        expected_circuit=cirq.Circuit(
-            cirq.Moment(CZ(*qubits[4:6])),
-            cirq.Moment(CZ(*qubits[3:5]), X(qubits[5])),
-            cirq.Moment(CZ(*qubits[2:4]), CZ(*qubits[5:7])),
-            cirq.Moment(CZ(*qubits[1:3]), CZ(*qubits[6:8]), X(qubits[5])),
-            cirq.Moment(CZ(*qubits[0:2]), CZ(*qubits[7:]), Z(qubits[6])),
-        ),
+        expected_circuit="""
+0: ───────────────────@───
+                      │
+1: ───────────────@───@───
+                  │
+2: ───────────@───@───────
+              │
+3: ───────@───@───────────
+          │
+4: ───@───@───────────────
+      │
+5: ───@───I───@───────────
+              │
+6: ───────────@───@───────
+                  │
+7: ───────────────@───@───
+                      │
+8: ───────────────────@───
+""",
         schema="XX_PAIR",
         single_qubit_gate_moments_only=False,
     )
@@ -494,14 +475,6 @@ def test_pull_through_chain() -> None:
     2: ───────────────×───×───X───
                           │
     3: ───────────────────×───X───
-    Output:
-    0: ───X───X───×───X───X───X───
-                  │
-    1: ───────Y───×───×───X───I───
-                      │
-    2: ───────────────×───×───X───
-                          │
-    3: ───────────────────×───I───
     """
     qubits = cirq.LineQubit.range(4)
     assert_dd(
@@ -513,14 +486,15 @@ def test_pull_through_chain() -> None:
             cirq.Moment(cirq.SWAP(*qubits[2:4])),
             cirq.Moment([X(qubits[i]) for i in range(4)]),
         ),
-        expected_circuit=cirq.Circuit(
-            cirq.Moment(X(qubits[0])),
-            cirq.Moment(Y(qubits[1]), X(qubits[0])),
-            cirq.Moment(cirq.SWAP(*qubits[0:2])),
-            cirq.Moment([cirq.SWAP(*qubits[1:3])] + [X(qubits[0])]),
-            cirq.Moment([cirq.SWAP(*qubits[2:4])] + [X(qubits[0]), X(qubits[1])]),
-            cirq.Moment(X(qubits[0]), cirq.I(qubits[1]), X(qubits[2]), cirq.I(qubits[3])),
-        ),
+        expected_circuit="""
+0: ───X───X───×───X───X───X───
+              │
+1: ───────Y───×───×───X───I───
+                  │
+2: ───────────────×───×───X───
+                      │
+3: ───────────────────×───I───
+""",
         schema='XX_PAIR',
         single_qubit_gate_moments_only=False,
     )
@@ -532,10 +506,6 @@ def test_multiple_clifford_pieces_case1() -> None:
     a: ───H───────H───────@───────────H───────H───
                           │
     b: ───H───H───H───H───@^0.5───H───H───H───H───
-    Output:
-    a: ───H───X───H───X───Y───@───────X───H───X───PhXZ(a=0.5,x=0.5,z=-1)───
-                              │
-    b: ───H───H───H───H───────@^0.5───H───H───H───H────────────────────────
     """
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
@@ -552,9 +522,9 @@ def test_multiple_clifford_pieces_case1() -> None:
             cirq.Moment(H(a), H(b)),
         ),
         expected_circuit="""
-a: ───H───X───H───X───Y───@───────X───H───X───PhXZ(a=0.5,x=0.5,z=-1)───
-                          │
-b: ───H───H───H───H───────@^0.5───H───H───H───H────────────────────────
+a: ───H───X───H───PhXZ(a=-0.5,x=0,z=-1)───@───────X───H───X───PhXZ(a=0.5,x=0.5,z=-1)───
+                                          │
+b: ───H───H───H───H───────────────────────@^0.5───H───H───H───H────────────────────────
 """,
         schema="XX_PAIR",
     )
@@ -566,10 +536,6 @@ def test_multiple_clifford_pieces_case2() -> None:
     a: ───@───PhXZ(a=0.3,x=0.2,z=0)───PhXZ(a=0.3,x=0.2,z=0)───PhXZ(a=0.3,x=0.2,z=0)───@───
           │                                                                           │
     b: ───@───────────────────────────────────────────────────────────────────────────@───
-    Output:
-    a: ───@───PhXZ(a=0.3,x=0.2,z=0)───PhXZ(a=0.3,x=0.2,z=0)───PhXZ(a=0.3,x=0.2,z=0)───@───Z───
-          │                                                                           │
-    b: ───@───X───────────────────────X───────────────────────X───────────────────────@───X───
     """
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
@@ -583,20 +549,17 @@ def test_multiple_clifford_pieces_case2() -> None:
             cirq.Moment(phased_xz_gate.on(a)),
             cirq.Moment(CZ(a, b)),
         ),
-        expected_circuit=cirq.Circuit(
-            cirq.Moment(CZ(a, b)),
-            cirq.Moment(phased_xz_gate.on(a), X(b)),
-            cirq.Moment(phased_xz_gate.on(a), X(b)),
-            cirq.Moment(phased_xz_gate.on(a), X(b)),
-            cirq.Moment(CZ(a, b)),
-            cirq.Moment(Z(a), X(b)),
-        ),
+        expected_circuit="""
+a: ───@───PhXZ(a=0.3,x=0.2,z=0)───PhXZ(a=0.3,x=0.2,z=0)───PhXZ(a=0.3,x=0.2,z=0)───@───
+      │                                                                           │
+b: ───@───X───────────────────────X───────────────────────I───────────────────────@───
+""",
         schema='XX_PAIR',
         single_qubit_gate_moments_only=False,
     )
 
 
-def test_insert_new_moment() -> None:
+def test_absorb_remaining_dd_sequence() -> None:
     """Test case diagrams.
     Input:
     a: ───H───────H───@───@───────
@@ -604,12 +567,6 @@ def test_insert_new_moment() -> None:
     b: ───H───H───H───X───@^0.5───
 
     c: ───H───────────────H───────
-    Output:
-    a: ───H───X───H───@───Z───@────────────────────────
-                      │       │
-    b: ───H───H───H───X───────@^0.5────────────────────
-
-    c: ───H───X───X───────X───PhXZ(a=-0.5,x=0.5,z=0)───
     """
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
@@ -622,17 +579,13 @@ def test_insert_new_moment() -> None:
             cirq.Moment(CNOT(a, b)),
             cirq.Moment(CZPowGate(exponent=0.5).on(a, b), H(c)),
         ),
-        expected_circuit=cirq.Circuit(
-            cirq.Moment(H(a), H(b), H(c)),
-            cirq.Moment(H(b), X(a), X(c)),
-            cirq.Moment(H(a), H(b), X(c)),
-            cirq.Moment(CNOT(a, b)),
-            cirq.Moment(Z(a), X(c)),
-            cirq.Moment(
-                CZPowGate(exponent=0.5).on(a, b),
-                cirq.PhasedXZGate(axis_phase_exponent=-0.5, x_exponent=0.5, z_exponent=0).on(c),
-            ),
-        ),
+        expected_circuit="""
+a: ───H───X───PhXZ(a=-0.5,x=0.5,z=0)───@───@───────
+                                       │   │
+b: ───H───H───H────────────────────────X───@^0.5───
+
+c: ───H───X───X────────────────────────────H───────        
+""",
         schema="XX_PAIR",
     )
 
@@ -659,13 +612,13 @@ def test_with_non_clifford_measurements() -> None:
             cirq.Moment([cirq.M(qubits[i]) for i in [0, 1, 2, 3]]),
         ),
         expected_circuit="""
-0: ───────────H───@───H───X───M───
+0: ───────────H───@───PhXZ(a=0.5,x=0.5,z=0)───M───
                   │
-1: ───H───@───X───@───X───────M───
+1: ───H───@───X───@───X───────────────────────M───
           │
-2: ───H───@───H───@───X───X───M───
+2: ───H───@───H───@───I───────────────────────M───
                   │
-3: ───────────H───@───H───────M───
+3: ───────────H───@───H───────────────────────M───
 """,
         schema="XX_PAIR",
         single_qubit_gate_moments_only=True,
@@ -688,21 +641,6 @@ def test_cross_clifford_pieces_filling_merge() -> None:
     5: ───PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)───H───
                                                                                                                       │
     6: ───────────────────────────────────────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)─────────────────────────────@───PhXZ(a=0.2,x=0.2,z=0.1)───H───
-    Output:
-
-    0: ─────────────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)─────H────────────────────────
-                                                                  │                                                   │
-    1: ─────────────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)─────H────────────────────────
-
-    2: ───PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───X───────────────────────────PhXZ(a=0.5,x=0.5,z=-1)───
-                                    │                             │                                                   │
-    3: ─────────────────────────────┼───PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────X─────────────────────────@───Y───────────────────────────PhXZ(a=0.5,x=0.5,z=0)────
-                                    │
-    4: ─────────────────────────────┼─────────────────────────────@─────────────────────────X─────────────────────────────Y───────────────────────────PhXZ(a=0.5,x=0.5,z=0)────
-                                    │                             │
-    5: ───PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=-0.8,x=0.2,z=-0.9)───H────────────────────────
-                                                                                                                      │
-    6: ───────────────────────────────────────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───X─────────────────────────@───PhXZ(a=0.8,x=0.8,z=0.5)─────H────────────────────────
     """  # noqa: E501
     qubits = cirq.LineQubit.range(7)
     phased_xz_gate = cirq.PhasedXZGate(axis_phase_exponent=0.2, x_exponent=0.2, z_exponent=0.1)
@@ -721,30 +659,31 @@ def test_cross_clifford_pieces_filling_merge() -> None:
             cirq.Moment([H.on(q) for q in qubits]),
         ),
         expected_circuit="""
-0: ─────────────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)─────H────────────────────────
+0: ─────────────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)───H────────────────────────
                                                               │                                                   │
-1: ─────────────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)─────H────────────────────────
+1: ─────────────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)───H────────────────────────
 
-2: ───PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───X───────────────────────────PhXZ(a=0.5,x=0.5,z=-1)───
+2: ───PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───X─────────────────────────PhXZ(a=0.5,x=0.5,z=-1)───
                                 │                             │                                                   │
-3: ─────────────────────────────┼───PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────X─────────────────────────@───Y───────────────────────────PhXZ(a=0.5,x=0.5,z=0)────
+3: ─────────────────────────────┼───PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────X─────────────────────────@───Y─────────────────────────PhXZ(a=0.5,x=0.5,z=0)────
                                 │
-4: ─────────────────────────────┼─────────────────────────────@─────────────────────────X─────────────────────────────Y───────────────────────────PhXZ(a=0.5,x=0.5,z=0)────
+4: ─────────────────────────────┼─────────────────────────────@─────────────────────────X─────────────────────────────Y─────────────────────────PhXZ(a=0.5,x=0.5,z=0)────
                                 │                             │
-5: ───PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=-0.8,x=0.2,z=-0.9)───H────────────────────────
+5: ───PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)───H────────────────────────
                                                                                                                   │
-6: ───────────────────────────────────────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───X─────────────────────────@───PhXZ(a=0.8,x=0.8,z=0.5)─────H────────────────────────
+6: ───────────────────────────────────────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───I─────────────────────────@───PhXZ(a=0.2,x=0.2,z=0.1)───H────────────────────────
 """,  # noqa: E501
     )
 
 
 def test_pull_through_phxz_gate_case1() -> None:
     """Test case diagrams.
-        Input:
+
+    Input:
     a: ───H───────PhXZ(a=0.25,x=-1,z=0)───────@───
                                               │
     b: ───H───H───H───────────────────────H───X───
-        Output: expected circuit diagram below.
+    Output: expected circuit diagram below.
     """
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
@@ -759,9 +698,9 @@ def test_pull_through_phxz_gate_case1() -> None:
             cirq.Moment(CNOT(a, b)),
         ),
         expected_circuit="""
-a: ───H───X───PhXZ(a=0.25,x=-1,z=0)───X───@───Z───
-                                          │
-b: ───H───H───H───────────────────────H───X───────
+a: ───H───X───PhXZ(a=0.25,x=-1,z=0)───PhXZ(a=0.5,x=1,z=0)───@───
+                                                            │
+b: ───H───H───H───────────────────────H─────────────────────X───
 """,
         schema="XX_PAIR",
     )
@@ -769,11 +708,12 @@ b: ───H───H───H───────────────
 
 def test_pull_through_phxz_gate_case2() -> None:
     """Test case diagrams.
-        Input:
+
+    Input:
     a: ───H───────PhXZ(a=0.2,x=-1,z=0)───────@───
                                               │
     b: ───H───H───H───────────────────────H───X───
-        Output: expected circuit diagram below.
+    Output: expected circuit diagram below.
     """
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
@@ -788,9 +728,9 @@ def test_pull_through_phxz_gate_case2() -> None:
             cirq.Moment(CNOT(a, b)),
         ),
         expected_circuit="""
-a: ───H───X───PhXZ(a=0.1,x=0,z=0.4)───X───@───X───
-                                          │
-b: ───H───H───H───────────────────────H───X───X───
+a: ───H───I───PhXZ(a=0.2,x=-1,z=0)───I───@───
+                                         │
+b: ───H───H───H──────────────────────H───X───
 """,
         schema="XX_PAIR",
     )
@@ -819,58 +759,112 @@ def test_merge_before_non_cliffords() -> None:
     assert_dd(
         input_circuit=input_circuit,
         expected_circuit="""
-0: ───X───X───X───────────────────────X──────────────────────X───M───
+0: ───X───X───X──────────────────────────────────────────M───
 
-1: ───X───X───PhXZ(a=-1,x=0,z=-0.5)───Y───FSim(0, 0.0637π)───────M───
-                                          │
-2: ───X───X───S───────────────────────────FSim(0, 0.0637π)───────M───
+1: ───X───X───PhXZ(a=-1.25,x=1,z=0)───FSim(0, 0.0637π)───M───
+                                      │
+2: ───X───X───S───────────────────────FSim(0, 0.0637π)───M───
 """,
         schema="XX_PAIR",
     )
 
 
-@pytest.mark.parametrize(
-    'single_qubit_gate_moments_only, expected_diagram',
-    [
-        (
-            True,
-            # With single_qubit_gate_moments_only=True, the second DD gate on q2
-            # is inserted in a new moment after the CZ gate.
-            """
-0: ───X───X───@───────M───
-              │
-1: ───X───X───@───────M───
+def test_runtime_error_if_pulled_through_not_empty_mocked() -> None:
+    """Tests that a RuntimeError is raised if pulled_through is not empty at the end.
 
-2: ───X───X───────X───M───
-""",
-        ),
-        (
-            False,
-            # With single_qubit_gate_moments_only=False, the second DD gate on q2
-            # is inserted in the same moment as the CZ gate.
-            """
-0: ───X───X───@───M───
-              │
-1: ───X───X───@───M───
+    This test explicitly mocks the internal state to simulate a scenario where
+    the `pulled_through` PauliString is not empty after processing all moments.
+    Under normal operation, the `_Grid` and `add_dynamical_decoupling`
+    logic should ensure `pulled_through` is always empty at the end, making
+    this RuntimeError theoretically unreachable. This test verifies the
+    defensive check itself.
+    """
+    q0: cirq.Qid = cirq.NamedQubit('q0')
+    circuit = cirq.FrozenCircuit(cirq.Moment(cirq.I(q0)))  # A minimal circuit
 
-2: ───X───X───X───M───
-""",
-        ),
-    ],
-)
-def test_single_qubit_gate_moments_only_true_vs_false(
-    single_qubit_gate_moments_only, expected_diagram
-) -> None:
+    # Create a mock _Grid instance that would lead to an unabsorbed Pauli.
+    # We need an INSERTABLE slot, but no STOP label, and no self-cancellation.
+    # To achieve this, we'll mock the `pulled_through.after` method to *not* clear it.
+    # This is a deep mock to hit the specific RuntimeError line.
+
+    # First, create a _Grid that allows insertion but no stopping.
+    # This is a hypothetical scenario that `_Grid.from_circuit` should prevent.
+    mock_gate_types = {q0: {0: _CellType.INSERTABLE}}
+    mock_need_to_stop = {q0: {0: False}}  # Crucially, no stop gate
+
+    mock_labeled_circuit = _Grid(
+        gate_types=mock_gate_types, need_to_stop=mock_need_to_stop, circuit=circuit
+    )
+
+    # Mock _Grid.from_circuit to return our custom mock
+    with mock.patch(
+        'cirq.transformers.dynamical_decoupling._Grid.from_circuit',
+        return_value=mock_labeled_circuit,
+    ):
+        # Mock the PauliString.after method to ensure `pulled_through` remains non-empty.
+        with mock.patch('cirq.ops.PauliString.after', return_value=cirq.PauliString({q0: cirq.X})):
+            with pytest.raises(
+                RuntimeError, match="Expect empty remaining Paulis after the dd insertion."
+            ):
+                add_dynamical_decoupling(
+                    circuit, schema='XX_PAIR', single_qubit_gate_moments_only=True
+                )
+
+
+def test_labeled_circuit_str():
+    """Input circuit:
+    0: ───X──────────────────────────────────────────────────M───
+
+    1: ───X───────PhXZ(a=-1,x=0,z=-0.5)───FSim(0, 0.0637π)───M───
+                                          │
+    2: ───X───X───S───────────────────────FSim(0, 0.0637π)───M───
+    """
     q0, q1, q2 = cirq.LineQubit.range(3)
     input_circuit = cirq.Circuit(
         cirq.Moment([X(q) for q in [q0, q1, q2]]),
-        cirq.Moment([X(q) for q in [q0, q1]]),
-        cirq.Moment(CZ(q0, q1)),
+        cirq.Moment(X(q2)),
+        cirq.Moment(
+            cirq.PhasedXZGate(axis_phase_exponent=-1, x_exponent=0, z_exponent=-0.5).on(q1),
+            (Z**0.5).on(q2),
+        ),
+        cirq.Moment(cirq.FSimGate(theta=0, phi=0.2).on(q1, q2)),
         cirq.Moment([cirq.M(q) for q in [q0, q1, q2]]),
     )
-    assert_dd(
-        input_circuit=input_circuit,
-        expected_circuit=expected_diagram,
-        schema="XX_PAIR",
-        single_qubit_gate_moments_only=single_qubit_gate_moments_only,
+    labeled_circuit = _Grid.from_circuit(input_circuit, single_qubit_gate_moments_only=True)
+    assert str(labeled_circuit) == (
+        """Grid Repr:
+     |  0  |  1  |  2  |  3  |  4  |
+-----+-----+-----+-----+-----+-----+
+q(0) |  d  |  i  | i,s |  d  |  w  |
+q(1) |  d  |  i  | d,s |  w  |  w  |
+q(2) |  d  |  d  | d,s |  w  |  w  |"""
     )
+
+
+def test_labeled_circuit_str_empty():
+    """Tests the __str__ method of _Grid for empty and no-qubit circuits."""
+    # Test case for an empty circuit (no moments, no qubits)
+    empty_circuit = cirq.Circuit()
+    labeled_empty = _Grid.from_circuit(empty_circuit, single_qubit_gate_moments_only=True)
+    assert str(labeled_empty) == "Grid(empty)"
+
+
+def test_add_dynamical_decoupling_with_deep_context_raises_error():
+    """Tests that add_dynamical_decoupling raises an error with deep context."""
+    q = cirq.NamedQubit('q')
+    circuit = cirq.Circuit(cirq.H(q))
+    context = cirq.TransformerContext(deep=True)
+    with pytest.raises(ValueError, match="Deep transformation is not supported."):
+        add_dynamical_decoupling(circuit, context=context)
+
+
+def test_context_logger():
+    q = cirq.NamedQubit('q')
+    circuit = cirq.Circuit(cirq.H(q))
+    mock_logger = mock.MagicMock(spec=cirq.TransformerLogger)
+    context = cirq.TransformerContext(logger=mock_logger)
+
+    add_dynamical_decoupling(circuit, context=context)
+
+    mock_logger.log.assert_called_once()
+    assert "Preprocessed input circuit grid repr:" in mock_logger.log.call_args[0][0]

cirq/value/digits.py

@@ -168,6 +168,11 @@ def big_endian_int_to_digits(
         >>> cirq.big_endian_int_to_digits(11, base=[2, 3, 4])
         [0, 2, 3]
     """
+    if digit_count and base == 2:
+        binary_chars = bin(val).removeprefix('0b')
+        zeros_count = digit_count - len(binary_chars)
+        if zeros_count >= 0:
+            return [0] * zeros_count + [1 if c == "1" else 0 for c in binary_chars]
     if isinstance(base, int):
         if digit_count is None:
             raise ValueError('No digit count. Provide `digit_count` when base is an int.')
@@ -192,4 +197,5 @@ def big_endian_int_to_digits(
             f'left behind {val!r} instead of 0.'
         )
 
-    return result[::-1]
+    result.reverse()
+    return result

{cirq_core-1.7.0.dev20251027223253.dist-info → cirq_core-1.7.0.dev20251028035559.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cirq-core
-Version: 1.7.0.dev20251027223253
+Version: 1.7.0.dev20251028035559
 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.dev20251027223253.dist-info → cirq_core-1.7.0.dev20251028035559.dist-info}/RECORD

@@ -4,8 +4,8 @@ cirq/_compat_test.py,sha256=emXpdD5ZvwLRlFAoQB8YatmZyU3b4e9jg6FppMTUhkU,33900
 cirq/_doc.py,sha256=28ZskY9ZtZ_4GS1oXPUgklKnJqmAE-rkUfzcsJ0--nA,2941
 cirq/_import.py,sha256=ixBu4EyGl46Ram2cP3p5eZVEFDW5L2DS-VyTjz4N9iw,8429
 cirq/_import_test.py,sha256=oF4izzOVZLc7NZ0aZHFcGv-r01eiFFt_JORx_x7_D4s,1089
-cirq/_version.py,sha256=BmdO4cyKFStXrt480p3Mv_-7j3gJ9YmLzCSMRZZCDPc,1206
-cirq/_version_test.py,sha256=1C8u7qSEY-CD8qEE9JWJeCunUYG-cZBRysU5ClZVdVE,155
+cirq/_version.py,sha256=hwKIrLaPuF0ICgE1qbNArfVRn9cZA8_8VnpdaPSokDM,1206
+cirq/_version_test.py,sha256=kvN_UM8XK-zjfJ6SXpp97upPv198bIXsvNPxFrqa4GI,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
@@ -1078,8 +1078,8 @@ cirq/transformers/drop_empty_moments.py,sha256=uZJG9FpUNyA1Mi0xLDuVuhj_siZhPZ1_s
 cirq/transformers/drop_empty_moments_test.py,sha256=h6Pji0z0o9KOB7fnSHseWpIAhzvxWurF_flg9XWm_YI,1959
 cirq/transformers/drop_negligible_operations.py,sha256=eP2dP_n0BYlr8aZ1wnD8YWsqCtwN0l0O6p45RbXEpfM,2097
 cirq/transformers/drop_negligible_operations_test.py,sha256=LrZDDITL5dskTywIahZqZBWnIXAJqNAjOgd4EYfrYTA,3908
-cirq/transformers/dynamical_decoupling.py,sha256=LP0Hrp7XqfVRmSy_wQX85GKPgK1Vy2_HCt8OyySFL2s,13484
-cirq/transformers/dynamical_decoupling_test.py,sha256=E0dlZ2D7yCFr5a0SndLjr9Kv_-Iu5q-Nj_YIlN7IgYU,45339
+cirq/transformers/dynamical_decoupling.py,sha256=H0sOVKce3-NV-B8onp_S-mWU50EFJ9GJxJqKpQrYoCU,15113
+cirq/transformers/dynamical_decoupling_test.py,sha256=Dc0zc2civgbJcj8KXFCNDrvCXRPuZfCetIZ9XgHf5Qc,43029
 cirq/transformers/eject_phased_paulis.py,sha256=gK1XIslsBPFcppUFacbhvzfhcnK5ZSVcyLN1SM5wTEE,14072
 cirq/transformers/eject_phased_paulis_test.py,sha256=CQ5sUmJg9ibgo9RS7265CfOPJ1JgbyGWG9aRRi44dxM,14252
 cirq/transformers/eject_z.py,sha256=890RYmv6qi4KgHi0LD1xEt2EQ4V7WzfS8lkqvZHt0r4,5860
@@ -1195,7 +1195,7 @@ cirq/value/classical_data.py,sha256=SIxyyJyM0BavQxJJVnRN_ktFvv5QFEPPEewsr0muLVk,
 cirq/value/classical_data_test.py,sha256=q1QMT17E-X9kcaPw1oQqx3Hwnq3hyht24HaK3z7Udpo,5332
 cirq/value/condition.py,sha256=lJJcFiqG-r68DhhS01DS6HhQw0pDwbNq71bvH1Famec,11916
 cirq/value/condition_test.py,sha256=oEdim5nOYYY8UPU91H2xhb9MH8EC2WbMXTQ_DruHVO0,12949
-cirq/value/digits.py,sha256=-3HTHqEQqy5evUz8aLE6ruw0NV3ncuPrc5asRMQ-sQ4,6063
+cirq/value/digits.py,sha256=5hHOYTM4A7yhz-7RLlv3KTB3VPPfbx-gRp7M_pAVAd4,6330
 cirq/value/digits_test.py,sha256=WDeUQTnDqZXh4JjWu_qEkzCFAtd8x1UlN9I2yjdDV3g,3848
 cirq/value/duration.py,sha256=4K-eiCoFfzm2SM3K1OhV__YrW1GmzgA7QSkBpxOkTp8,10402
 cirq/value/duration_test.py,sha256=xQd5-dE8zZddsZru1P6ClV3PoeJncqLAQr3ivgZIXdQ,8281
@@ -1246,8 +1246,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.dev20251027223253.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.7.0.dev20251027223253.dist-info/METADATA,sha256=J0s0GJpqqiEpa6IuBpvEfhhB8bzRco6sEtBAVaV_sLE,4757
-cirq_core-1.7.0.dev20251027223253.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cirq_core-1.7.0.dev20251027223253.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.7.0.dev20251027223253.dist-info/RECORD,,
+cirq_core-1.7.0.dev20251028035559.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.7.0.dev20251028035559.dist-info/METADATA,sha256=V4zXcqoE990QTFmY9VzWqvWLSCTec-DJVfIMWESOK8s,4757
+cirq_core-1.7.0.dev20251028035559.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cirq_core-1.7.0.dev20251028035559.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.7.0.dev20251028035559.dist-info/RECORD,,