cirq-core 1.5.0.dev20250226233318__py3-none-any.whl → 1.5.0.dev20250228014434__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 10, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.1.*")'
     )
 
-__version__ = "1.5.0.dev20250226233318"
+__version__ = "1.5.0.dev20250228014434"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.5.0.dev20250226233318"
+    assert cirq.__version__ == "1.5.0.dev20250228014434"

cirq/ops/clifford_gate.py

@@ -377,7 +377,10 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
         #  ZI  [ 0  0 | 1  0  | 1 ]
         #  IZ  [ 1  0 | 1  1  | 0 ]
         # Take the third row as example: this means the ZI gate after the this gate,
-        # more precisely the conjugate transformation of ZI by this gate, becomes -ZI.
+        # more precisely the conjugate transformation of ZI by this gate, becomes -ZI:
+        #   ---(CliffordGate^-1)---ZI---CliffordGate---
+        # = unitary(CliffordGate)@unitary(ZI)@unitary(CliffordGate).conj().T
+        # = -ZI.
         # (Note the real clifford tableau has to satify the Symplectic property.
         # here is just for illustration)
         object.__setattr__(self, '_clifford_tableau', _clifford_tableau.copy())
@@ -438,7 +441,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
     def _commutes_(
         self, other: Any, *, atol: float = 1e-8
     ) -> Union[bool, NotImplementedType, None]:
-        # Note even if we assume two gates define the tabluea based on the same qubit order,
+        # Note even if we assume two gates define the tableau based on the same qubit order,
         # the following approach cannot judge it:
         # self.clifford_tableau.then(other.clifford_tableau) == other.clifford_tableau.then(
         #     self.clifford_tableau

cirq/ops/pauli_string.py

@@ -55,6 +55,7 @@ from cirq.ops import (
     pauli_gates,
     pauli_interaction_gate,
     raw_types,
+    dense_pauli_string,
 )
 
 if TYPE_CHECKING:
@@ -907,14 +908,13 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         Raises:
             ValueError: If the number of qubits is too small.
         """
-        from cirq.ops.dense_pauli_string import DensePauliString
 
         if not self.keys() <= set(qubits):
             raise ValueError('not self.keys() <= set(qubits)')
         # pylint: disable=too-many-function-args
         pauli_mask = [self.get(q, identity.I) for q in qubits]
         # pylint: enable=too-many-function-args
-        return DensePauliString(pauli_mask, coefficient=self.coefficient)
+        return dense_pauli_string.DensePauliString(pauli_mask, coefficient=self.coefficient)
 
     def conjugated_by(self, clifford: 'cirq.OP_TREE') -> 'PauliString':
         r"""Returns the Pauli string conjugated by a clifford operation.
@@ -976,17 +976,68 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         Returns:
             The Pauli string conjugated by the given Clifford operation.
         """
-        pauli_map = dict(self._qubit_pauli_map)
-        should_negate = False
-        for op in list(op_tree.flatten_to_ops(clifford))[::-1]:
-            if pauli_map.keys().isdisjoint(set(op.qubits)):
-                continue
-            for clifford_op in _decompose_into_cliffords(op)[::-1]:
-                if pauli_map.keys().isdisjoint(set(clifford_op.qubits)):
-                    continue
-                should_negate ^= _pass_operation_over(pauli_map, clifford_op, False)
-        coef = -self._coefficient if should_negate else self.coefficient
-        return PauliString(qubit_pauli_map=pauli_map, coefficient=coef)
+
+        # Initialize the ps the same as self.
+        ps = PauliString(qubit_pauli_map=self._qubit_pauli_map, coefficient=self.coefficient)
+        all_ops = list(op_tree.flatten_to_ops(clifford))
+        all_qubits = set.union(set(self.qubits), [q for op in all_ops for q in op.qubits])
+
+        # Iteratively calculate the conjugation in reverse order of ops.
+        for op in all_ops[::-1]:
+            # To calcuate the conjugation of P (`ps`) with respect to C (`op`)
+            # Decompose P = Pc⊗R, where Pc acts on the same qubits as C, R acts on the remaining.
+            # Then the conjugation = (C^{-1}⊗I·Pc⊗R·C⊗I) = (C^{-1}·Pc·C)⊗R.
+
+            # Isolate R
+            remain: 'cirq.PauliString' = PauliString()
+            for q in all_qubits:
+                pauli = ps.get(q)
+                if pauli is not None and not q in op.qubits:
+                    remain *= pauli(q)
+
+            # Initialize the conjugation of Pc.
+            conjugated: 'cirq.DensePauliString' = (
+                dense_pauli_string.DensePauliString(pauli_mask=[identity.I for _ in op.qubits])
+                * self.coefficient
+            )
+
+            # Calculate the conjugation via CliffordGate's clifford_tableau.
+            # Note the clifford_tableau in CliffordGate represents C·P·C^-1 instead of C^-1·P·C.
+            # So we take the inverse of the tableau to match the definition of the conjugation here.
+            gate_in_clifford: 'cirq.CliffordGate'
+            if isinstance(op.gate, cirq.CliffordGate):
+                gate_in_clifford = op.gate
+            else:
+                # Convert the clifford gate to CliffordGate type.
+                gate_in_clifford = clifford_gate.CliffordGate.from_op_list([op], op.qubits)
+            tableau = gate_in_clifford.clifford_tableau.inverse()
+
+            # Calculate the conjugation by `op` via mutiplying the conjugation of each Pauli:
+            #   C^{-1}·(P_1⊗...⊗P_n)·C
+            # = C^{-1}·(P_1⊗I) ...·(P_n⊗I)·C
+            # = (C^{-1}(P_1⊗I)C)·...·(C^{-1}(P_n⊗I)C)
+            # For the Pauli on the kth qubit P_k. The conjugation is calculated as following.
+            #   Puali X_k's conjugation is from the destabilzer table;
+            #   Puali Z_k's conjugation is from the stabilzer table;
+            #   Puali Y_k's conjugation is calcluated according to Y = iXZ. E.g., for the kth qubit,
+            #     C^{-1}·Y_k⊗I·C = C^{-1}·(iX_k⊗I·Z_k⊗I)·C = i (C^{-1}·X_k⊗I·C)·(C^{-1}·Z_k⊗I·C)
+            for qid, qubit in enumerate(op.qubits):
+                pauli = ps.get(qubit)
+                match pauli:
+                    case None:
+                        continue
+                    case pauli_gates.X:
+                        conjugated *= tableau.destabilizers()[qid]
+                    case pauli_gates.Z:
+                        conjugated *= tableau.stabilizers()[qid]
+                    case pauli_gates.Y:
+                        conjugated *= (
+                            1j
+                            * tableau.destabilizers()[qid]  # conj X first
+                            * tableau.stabilizers()[qid]  # then conj Z
+                        )
+            ps = remain * conjugated.on(*op.qubits)
+        return ps
 
     def after(self, ops: 'cirq.OP_TREE') -> 'cirq.PauliString':
         r"""Determines the equivalent pauli string after some operations.

cirq/ops/pauli_string_test.py

@@ -57,6 +57,22 @@ def _small_sample_qubit_pauli_maps():
     yield {qubits[0]: cirq.Z, qubits[1]: cirq.X, qubits[2]: cirq.Y}
 
 
+def assert_conjugation(
+    input_ps: cirq.PauliString, ops: cirq.OP_TREE, expected: cirq.PauliString | None
+):
+    conjugation = input_ps.conjugated_by(ops)
+    if expected is not None:
+        assert conjugation == expected
+    else:  # Compares the unitary of the conjugation result and the expected unitary.
+        op_list = list(cirq.flatten_to_ops(ops))
+        qubits_of_clifford = [q for op in op_list for q in op.qubits]
+        clifford = cirq.CliffordGate.from_op_list(op_list, qubits_of_clifford)
+        actual_unitary = cirq.unitary(conjugation.dense(qubits_of_clifford))
+        c = cirq.unitary(clifford)
+        expected_unitary = np.conj(c.T) @ cirq.unitary(input_ps.dense(qubits_of_clifford)) @ c
+        assert np.allclose(actual_unitary, expected_unitary, atol=1e-8)
+
+
 def test_eq_ne_hash():
     q0, q1, q2 = _make_qubits(3)
     eq = cirq.testing.EqualsTester()
@@ -1381,13 +1397,24 @@ def test_pauli_string_expectation_from_state_vector_mixed_state_linearity():
 def test_conjugated_by_normal_gates():
     a = cirq.LineQubit(0)
 
-    assert cirq.X(a).conjugated_by(cirq.H(a)) == cirq.Z(a)
-    assert cirq.Y(a).conjugated_by(cirq.H(a)) == -cirq.Y(a)
-    assert cirq.Z(a).conjugated_by(cirq.H(a)) == cirq.X(a)
+    assert_conjugation(cirq.X(a), cirq.H(a), cirq.Z(a))
+    assert_conjugation(cirq.Y(a), cirq.H(a), -cirq.Y(a))
+    assert_conjugation(cirq.Z(a), cirq.H(a), cirq.X(a))
+
+    assert_conjugation(cirq.X(a), cirq.S(a), -cirq.Y(a))
+    assert_conjugation(cirq.Y(a), cirq.S(a), cirq.X(a))
+    assert_conjugation(cirq.Z(a), cirq.S(a), cirq.Z(a))
+
+    clifford_op = cirq.PhasedXZGate(axis_phase_exponent=0.25, x_exponent=-1, z_exponent=0).on(a)
+    assert_conjugation(cirq.X(a), clifford_op, cirq.Y(a))
+    assert_conjugation(cirq.Y(a), clifford_op, cirq.X(a))
+    assert_conjugation(cirq.Z(a), clifford_op, -cirq.Z(a))
+
+
+def test_conjugated_by_op_gate_of_clifford_gate_type():
+    a = cirq.LineQubit(0)
 
-    assert cirq.X(a).conjugated_by(cirq.S(a)) == -cirq.Y(a)
-    assert cirq.Y(a).conjugated_by(cirq.S(a)) == cirq.X(a)
-    assert cirq.Z(a).conjugated_by(cirq.S(a)) == cirq.Z(a)
+    assert_conjugation(cirq.X(a), cirq.CliffordGate.from_op_list([cirq.H(a)], [a]).on(a), cirq.Z(a))
 
 
 def test_dense():
@@ -1430,16 +1457,25 @@ def test_conjugated_by_incorrectly_powered_cliffords():
         cirq.ZZ(a, b),
     ]
     for c in cliffords:
-        with pytest.raises(TypeError, match='not a known Clifford'):
+        with pytest.raises(
+            ValueError,
+            match='Clifford Gate can only be constructed from the operations'
+            ' that has stabilizer effect.',
+        ):
             _ = p.conjugated_by(c**0.1)
-        with pytest.raises(TypeError, match='not a known Clifford'):
+        with pytest.raises(
+            ValueError,
+            match='Clifford Gate can only be constructed from the operations'
+            ' that has stabilizer effect.',
+        ):
             _ = p.conjugated_by(c ** sympy.Symbol('t'))
 
 
 def test_conjugated_by_global_phase():
+    """Global phase gate preserves PauliString."""
     a = cirq.LineQubit(0)
-    assert cirq.X(a).conjugated_by(cirq.global_phase_operation(1j)) == cirq.X(a)
-    assert cirq.Z(a).conjugated_by(cirq.global_phase_operation(np.exp(1.1j))) == cirq.Z(a)
+    assert_conjugation(cirq.X(a), cirq.global_phase_operation(1j), cirq.X(a))
+    assert_conjugation(cirq.X(a), cirq.global_phase_operation(np.exp(1.1j)), cirq.X(a))
 
     class DecomposeGlobal(cirq.Gate):
         def num_qubits(self):
@@ -1448,7 +1484,7 @@ def test_conjugated_by_global_phase():
         def _decompose_(self, qubits):
             yield cirq.global_phase_operation(1j)
 
-    assert cirq.X(a).conjugated_by(DecomposeGlobal().on(a)) == cirq.X(a)
+    assert_conjugation(cirq.X(a), DecomposeGlobal().on(a), cirq.X(a))
 
 
 def test_conjugated_by_composite_with_disjoint_sub_gates():
@@ -1461,8 +1497,10 @@ def test_conjugated_by_composite_with_disjoint_sub_gates():
         def _decompose_(self, qubits):
             yield cirq.H(qubits[1])
 
-    assert cirq.X(a).conjugated_by(DecomposeDisjoint().on(a, b)) == cirq.X(a)
-    assert cirq.X(a).pass_operations_over([DecomposeDisjoint().on(a, b)]) == cirq.X(a)
+    for g1 in [cirq.X, cirq.Y]:
+        for g2 in [cirq.X, cirq.Y]:
+            ps = g1(a) * g2(b)
+            assert ps.conjugated_by(DecomposeDisjoint().on(a, b)) == ps.conjugated_by(cirq.H(b))
 
 
 def test_conjugated_by_clifford_composite():
@@ -1477,16 +1515,16 @@ def test_conjugated_by_clifford_composite():
             yield cirq.SWAP(qubits[2], qubits[3])
 
     a, b, c, d = cirq.LineQubit.range(4)
-    p = cirq.X(a) * cirq.Z(b)
+    ps = cirq.X(a) * cirq.Z(b)
     u = UnknownGate()
-    assert p.conjugated_by(u(a, b, c, d)) == cirq.Z(a) * cirq.X(b)
+    assert_conjugation(ps, u(a, b, c, d), cirq.Z(a) * cirq.X(b))
 
 
 def test_conjugated_by_move_into_uninvolved():
     a, b, c, d = cirq.LineQubit.range(4)
-    p = cirq.X(a) * cirq.Z(b)
-    assert p.conjugated_by([cirq.SWAP(c, d), cirq.SWAP(b, c)]) == cirq.X(a) * cirq.Z(d)
-    assert p.conjugated_by([cirq.SWAP(b, c), cirq.SWAP(c, d)]) == cirq.X(a) * cirq.Z(c)
+    ps = cirq.X(a) * cirq.Z(b)
+    assert_conjugation(ps, [cirq.SWAP(c, d), cirq.SWAP(b, c)], cirq.X(a) * cirq.Z(d))
+    assert_conjugation(ps, [cirq.SWAP(b, c), cirq.SWAP(c, d)], cirq.X(a) * cirq.Z(c))
 
 
 def test_conjugated_by_common_single_qubit_gates():
@@ -1508,21 +1546,13 @@ def test_conjugated_by_common_single_qubit_gates():
     single_qubit_gates = [g**i for i in range(4) for g in base_single_qubit_gates]
     for p in [cirq.X, cirq.Y, cirq.Z]:
         for g in single_qubit_gates:
-            assert p.on(a).conjugated_by(g.on(b)) == p.on(a)
-
-            actual = cirq.unitary(p.on(a).conjugated_by(g.on(a)))
-            u = cirq.unitary(g)
-            expected = np.conj(u.T) @ cirq.unitary(p) @ u
-            assert cirq.allclose_up_to_global_phase(actual, expected, atol=1e-8)
+            # pauli gate on a, clifford on b: pauli gate preserves.
+            assert_conjugation(p(a), g(b), p(a))
+            # pauli gate on a, clifford on a: check conjugation in matrices.
+            assert_conjugation(p(a), g(a), None)
 
 
 def test_conjugated_by_common_two_qubit_gates():
-    class OrderSensitiveGate(cirq.Gate):
-        def num_qubits(self):
-            return 2
-
-        def _decompose_(self, qubits):
-            return [cirq.Y(qubits[0]) ** -0.5, cirq.CNOT(*qubits)]
 
     a, b, c, d = cirq.LineQubit.range(4)
     two_qubit_gates = [
@@ -1541,34 +1571,25 @@ def test_conjugated_by_common_two_qubit_gates():
         cirq.YY**-0.5,
         cirq.ZZ**-0.5,
     ]
-    two_qubit_gates.extend([OrderSensitiveGate()])
     for p1 in [cirq.I, cirq.X, cirq.Y, cirq.Z]:
         for p2 in [cirq.I, cirq.X, cirq.Y, cirq.Z]:
             pd = cirq.DensePauliString([p1, p2])
-            p = pd.sparse()
+            p = pd.sparse([a, b])
             for g in two_qubit_gates:
-                assert p.conjugated_by(g.on(c, d)) == p
-
-                actual = cirq.unitary(p.conjugated_by(g.on(a, b)).dense([a, b]))
-                u = cirq.unitary(g)
-                expected = np.conj(u.T) @ cirq.unitary(pd) @ u
-                np.testing.assert_allclose(actual, expected, atol=1e-8)
+                # pauli_string on (a,b), clifford on (c,d): pauli_string preserves.
+                assert_conjugation(p, g(c, d), p)
+                # pauli_string on (a,b), clifford on (a,b): compare unitaries of
+                # the conjugated_by and actual matrix conjugation.
+                assert_conjugation(p, g.on(a, b), None)
 
 
 def test_conjugated_by_ordering():
-    class OrderSensitiveGate(cirq.Gate):
-        def num_qubits(self):
-            return 2
-
-        def _decompose_(self, qubits):
-            return [cirq.Y(qubits[0]) ** -0.5, cirq.CNOT(*qubits)]
-
+    """Tests .conjugated_by([op1, op2]) == .conjugated_by(op2).conjugated_by(op1)"""
     a, b = cirq.LineQubit.range(2)
     inp = cirq.Z(b)
-    out1 = inp.conjugated_by(OrderSensitiveGate().on(a, b))
-    out2 = inp.conjugated_by([cirq.H(a), cirq.CNOT(a, b)])
-    out3 = inp.conjugated_by(cirq.CNOT(a, b)).conjugated_by(cirq.H(a))
-    assert out1 == out2 == out3 == cirq.X(a) * cirq.Z(b)
+    out1 = inp.conjugated_by([cirq.H(a), cirq.CNOT(a, b)])
+    out2 = inp.conjugated_by(cirq.CNOT(a, b)).conjugated_by(cirq.H(a))
+    assert out1 == out2 == cirq.X(a) * cirq.Z(b)
 
 
 def test_pass_operations_over_ordering():

cirq/ops/swap_gates.py

@@ -219,6 +219,11 @@ class ISwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate
         ]
         # yapf: enable
 
+    def _has_stabilizer_effect_(self) -> Optional[bool]:
+        if self._is_parameterized_():
+            return None
+        return self.exponent % 1 == 0
+
     def _decompose_(self, qubits):
         a, b = qubits
 

cirq/transformers/dynamical_decoupling.py

@@ -58,6 +58,8 @@ def _pauli_up_to_global_phase(gate: ops.Gate) -> Union[ops.Pauli, None]:
 def _validate_dd_sequence(dd_sequence: Tuple[ops.Gate, ...]) -> None:
     """Validates a given dynamical decoupling sequence.
 
+    The sequence should only consists of Pauli gates and is essentially an identity gate.
+
     Args:
         dd_sequence: Input dynamical sequence to be validated.
 
@@ -93,7 +95,7 @@ def _parse_dd_sequence(
         _validate_dd_sequence(schema)
         dd_sequence = schema
 
-    # Map Gate to Puali gate. This is necessary as dd sequence might contain gates like X^-1.
+    # Map gate to Pauli gate. This is necessary as dd sequence might contain gates like X^-1.
     pauli_map: Dict[ops.Gate, ops.Pauli] = {}
     for gate in dd_sequence:
         pauli_gate = _pauli_up_to_global_phase(gate)
@@ -171,19 +173,13 @@ def _try_merge_single_qubit_ops_of_two_moments(
 def _calc_pulled_through(
     moment: circuits.Moment, input_pauli_ops: ops.PauliString
 ) -> ops.PauliString:
-    """Calculates the pulled_through such that circuit(input_puali_ops, moment.clifford_ops) is
+    """Calculates the pulled_through such that circuit(input_pauli_ops, moment.clifford_ops) is
     equivalent to circuit(moment.clifford_ops, pulled_through).
     """
     clifford_ops_in_moment: list[ops.Operation] = [
         op for op in moment.operations if _is_clifford_op(op)
     ]
-    # TODO(#6946): directly pass clifford_ops_in_moment to input_pauli_ops.after() after #6946 is
-    # fixed.
-    affected_qubits = [q for op in clifford_ops_in_moment for q in op.qubits]
-    all_cliffords_in_gate: ops.CliffordGate = ops.CliffordGate.from_op_list(
-        clifford_ops_in_moment, affected_qubits
-    )
-    return input_pauli_ops.after(all_cliffords_in_gate.on(*affected_qubits))
+    return input_pauli_ops.after(clifford_ops_in_moment)
 
 
 def _get_stop_qubits(moment: circuits.Moment) -> set[ops.Qid]:
@@ -197,7 +193,7 @@ def _get_stop_qubits(moment: circuits.Moment) -> set[ops.Qid]:
 
 
 def _need_merge_pulled_through(op_at_q: ops.Operation, is_at_last_busy_moment: bool) -> bool:
-    """With a pulling through puali gate before op_at_q, need to merge with the
+    """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)):
@@ -234,7 +230,7 @@ def add_dynamical_decoupling(
 
     busy_moment_range_by_qubit = _calc_busy_moment_range_of_each_qubit(orig_circuit)
 
-    # Stores all the moments of the output circuit chronically
+    # Stores all the moments of the output circuit chronologically.
     transformed_moments: list[circuits.Moment] = []
     # A PauliString stores the result of 'pulling' Pauli gates past each operations
     # right before the current moment.
@@ -247,7 +243,7 @@ def add_dynamical_decoupling(
         pulled_through *= pauli_map[insert_gate].on(q)
         return insert_gate.on(q)
 
-    # Insert and pull remaining Puali ops through the whole circuit.
+    # 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).

{cirq_core-1.5.0.dev20250226233318.dist-info → cirq_core-1.5.0.dev20250228014434.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20250226233318
+Version: 1.5.0.dev20250228014434
 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.5.0.dev20250226233318.dist-info → cirq_core-1.5.0.dev20250228014434.dist-info}/RECORD

@@ -4,8 +4,8 @@ cirq/_compat_test.py,sha256=Qq3ZcfgD-Nb81cEppQdJqhAyrVqXKtfXZYGXT0p-Wh0,34718
 cirq/_doc.py,sha256=yDyWUD_2JDS0gShfGRb-rdqRt9-WeL7DhkqX7np0Nko,2879
 cirq/_import.py,sha256=p9gMHJscbtDDkfHOaulvd3Aer0pwUF5AXpL89XR8dNw,8402
 cirq/_import_test.py,sha256=6K_v0riZJXOXUphHNkGA8MY-JcmGlezFaGmvrNhm3OQ,1015
-cirq/_version.py,sha256=wMJgrMD0S2t64Vay6XocWM01xWLQRA8RHHpYdxR7V4s,1206
-cirq/_version_test.py,sha256=mtsql_KSNl0EmQlkOYcBY9p95XWMH-DfxV5SrQqwlCw,147
+cirq/_version.py,sha256=st5pfHdcuFvWhnPbf7jkrC0lPMUEM-8BDK1c2sNs2y4,1206
+cirq/_version_test.py,sha256=ECrpkOwO6IZplxoqJ3om2pdTZYD314hbVJCoRCiTZwU,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=p-vEOa-8GQ2cFIAdze-kd6C1un1uRvtujVPljVKaHBg,13557
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -271,7 +271,7 @@ cirq/ops/boolean_hamiltonian.py,sha256=li003lNq6zS8pNPTobqzfzYJvyvaIpCVo3wkliI6H
 cirq/ops/boolean_hamiltonian_test.py,sha256=1ey5yfYZPKZDsfM3jpCPAOpbPs_y8i4K_WvDK2d5_4Y,8518
 cirq/ops/classically_controlled_operation.py,sha256=M4NAcChYcz-a88oyIwOnV4uP06S18Cbef4VnhMmjyrA,10374
 cirq/ops/classically_controlled_operation_test.py,sha256=nIYyXfNH4E2IibZSLk6QDVHpfJQbuI_iWwirCH8rhi8,50209
-cirq/ops/clifford_gate.py,sha256=usI1Qs2RiTZyrD8OP2zptcJIamzi8EZcRglsYofKY5A,39749
+cirq/ops/clifford_gate.py,sha256=W3fDY04QlubdCLawmq-86WAcgYQxk0ugamVro8ABFDk,39899
 cirq/ops/clifford_gate_test.py,sha256=MQzZRURV--SPjRGLk_ESMBz75YXtKwtQGg2jufFDR0w,40341
 cirq/ops/common_channels.py,sha256=go4yhaRw0XNAr3TUBJ59SOhn2SKxf6bHmmrOHPbBYCY,37259
 cirq/ops/common_channels_test.py,sha256=nQsSSxu7vtedb3ZUuw4hNKIX7MYI4x8lxvLyWMZNt10,30079
@@ -333,12 +333,12 @@ cirq/ops/pauli_interaction_gate.py,sha256=Ep7XwZMVP81Qq1J2MTc3kJ79h26daOZcLPxqN3
 cirq/ops/pauli_interaction_gate_test.py,sha256=U9ORW5Ayx5PESPFiGESzWY-02qHklYcM1mYW56RWe_A,4544
 cirq/ops/pauli_measurement_gate.py,sha256=AS9tzLGAOhJzRzVsW9m-WPz5Wx0sMS1jzhppn5qtW84,7239
 cirq/ops/pauli_measurement_gate_test.py,sha256=uh3J0Ps3V3578V8qkRiEgIl6jBiv8DsXlk_vzLvOEhQ,6720
-cirq/ops/pauli_string.py,sha256=M40LNLf6_RhEtMW2VmF2rzySTCbQlmBELFEzp6msES0,67402
+cirq/ops/pauli_string.py,sha256=sGs0TZt1mtGUarDphJkTkNvKppdV1mB67eSJkKwQiug,70032
 cirq/ops/pauli_string_phasor.py,sha256=M5AGwwMueY-y7bl50KJHiYql7PF4AcsdBBZhsxkhCWE,17519
 cirq/ops/pauli_string_phasor_test.py,sha256=91YXIm9RbqrG8dPdA18E9i4G7JT1epGvM4BZu6_YVzw,27796
 cirq/ops/pauli_string_raw_types.py,sha256=6CgdPWYmOziP4uZbrIsRW0sDSMmV1GioGdAk0owFITU,2240
 cirq/ops/pauli_string_raw_types_test.py,sha256=SZPluslZPGffPq93F5apESBygWZ2cj7BEX6dQuawRQE,2648
-cirq/ops/pauli_string_test.py,sha256=ht9FDsphSQgb-dU2YqMuQvzzFKTMS3yS1hMrYbIvawY,74663
+cirq/ops/pauli_string_test.py,sha256=sE2Kje6qmHJzhdVja3fa3Er8g3XJ8l_8hzjgioSFIn4,75742
 cirq/ops/pauli_sum_exponential.py,sha256=_9JERthST1PRwunplPQKIaJaOL45Kbl1oJ5CYUJWlTU,4876
 cirq/ops/pauli_sum_exponential_test.py,sha256=wVnJ3FSpEimHT8ERVkmljALrgSuuDYo6GRg91uJ7ztk,5370
 cirq/ops/permutation_gate.py,sha256=2h8n76N2M3nu5MA8JkRQgVLByq5cOEluKUN042ClSRs,4196
@@ -364,7 +364,7 @@ cirq/ops/raw_types.py,sha256=pBnjIMgnX5426rzC6KQuUSbI3VL1iLAjpFrsqSygjtY,42092
 cirq/ops/raw_types_test.py,sha256=U2sAzc6DjpOmgHafGv94VJXqZHm7J898khmJoHAawHQ,33940
 cirq/ops/state_preparation_channel.py,sha256=PjVtoLbjBAy_XqnFAY40Am-NifeuCFVVLW6RJxph5sQ,4778
 cirq/ops/state_preparation_channel_test.py,sha256=yKUvLw_ft6cvIgRJcFQ779wZS-V6V-pzQq-rZRWdCmU,5922
-cirq/ops/swap_gates.py,sha256=8DrW7Hn-m0dx0e57FUPfjggRF0zC_HGbr3Eomm54jfE,11634
+cirq/ops/swap_gates.py,sha256=Rf3zF_dM6NM9LGvYqRr6QiX0qOxLBhp7yaFs-Awjog8,11792
 cirq/ops/swap_gates_test.py,sha256=_CihLf6rY4PNphCkH-S5mLJQYZW9ILjnnwUyQ9b0Blg,7452
 cirq/ops/tags.py,sha256=B3nEsZQTurGPJodH7aDoreNSatqawTxwsmw8fSKaIlc,2294
 cirq/ops/tags_test.py,sha256=4V9twOuCXd7Glvj9p3RW-tZ4-bfLtC1tmonR4soKNA0,1158
@@ -1045,7 +1045,7 @@ cirq/transformers/drop_empty_moments.py,sha256=Rtn_BrpwkLXyZBdLzwdnsnEGWTdYuf1xO
 cirq/transformers/drop_empty_moments_test.py,sha256=G8pZmTfi8NG2NpGz_K3LZu5NQoqa-xPMCuZjwEu07xk,1907
 cirq/transformers/drop_negligible_operations.py,sha256=8eyOMy7bra2wJAjORbk6QjwHiLdL5SfwRaz8D2Dazbw,2083
 cirq/transformers/drop_negligible_operations_test.py,sha256=gqL6RoDPm6Zf4RxtprBenFyIsZQPUxmPur9oRl0Yr3U,3823
-cirq/transformers/dynamical_decoupling.py,sha256=NiHZTN2TDgC7um61cP1J5GN_3fAlsK5kqAIYb8Q6aUg,14944
+cirq/transformers/dynamical_decoupling.py,sha256=w3Gv9_dFMl2u6h0oKWWYTUuYXDFTqgBlP5HT3NpSyCc,14700
 cirq/transformers/dynamical_decoupling_test.py,sha256=XCLH9Clco1KM6NXQmaVYCpUR1SALBRofgFgCH79RBuI,44690
 cirq/transformers/eject_phased_paulis.py,sha256=usuPCxHgZf6Aw6pqIU4vOvaOypH4SiT2lY8VwAnlObs,13975
 cirq/transformers/eject_phased_paulis_test.py,sha256=-mXsfbi3V0ojC_YqoQM5otzdW4kjGusCx6F-kCv8M98,15834
@@ -1202,8 +1202,8 @@ cirq/work/sampler.py,sha256=bE5tmVkcR6cZZMLETxDfHehdsYUMbx2RvBeIBetehI4,19187
 cirq/work/sampler_test.py,sha256=hL2UWx3dz2ukZVNxWftiKVvJcQoLplLZdQm-k1QcA40,13282
 cirq/work/zeros_sampler.py,sha256=x1C7cup66a43n-3tm8QjhiqJa07qcJW10FxNp9jJ59Q,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.5.0.dev20250226233318.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250226233318.dist-info/METADATA,sha256=oIbBZflbc50AQKvePmeJYCAefY0TLwId9dEbY2SQi3Q,4817
-cirq_core-1.5.0.dev20250226233318.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250226233318.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250226233318.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250228014434.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250228014434.dist-info/METADATA,sha256=rrCHAML9zdH0J9WXYJcziz7dhREyHw4v279vCCIUk2Q,4817
+cirq_core-1.5.0.dev20250228014434.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250228014434.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250228014434.dist-info/RECORD,,