cirq-core 1.5.0.dev20250312165047__py3-none-any.whl → 1.5.0.dev20250312231723__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.dev20250312165047"
+__version__ = "1.5.0.dev20250312231723"

cirq/_version_test.py

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

cirq/circuits/insert_strategy.py

@@ -23,6 +23,16 @@ class InsertStrategy:
     INLINE: 'InsertStrategy'
     EARLIEST: 'InsertStrategy'
 
+    def __new__(cls, name: str, doc: str) -> 'InsertStrategy':
+        inst = getattr(cls, name, None)
+        if not inst or not isinstance(inst, cls):
+            inst = super().__new__(cls)
+        return inst
+
+    def __getnewargs__(self):
+        """Returns a tuple of args to pass to __new__ when unpickling."""
+        return (self.name, self.__doc__)
+
     def __init__(self, name: str, doc: str):
         self.name = name
         self.__doc__ = doc

cirq/circuits/insert_strategy_test.py

@@ -12,8 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import pickle
+
+import pytest
+
 import cirq
 
 
 def test_repr():
     assert repr(cirq.InsertStrategy.NEW) == 'cirq.InsertStrategy.NEW'
+
+
+@pytest.mark.parametrize(
+    'strategy',
+    [
+        cirq.InsertStrategy.NEW,
+        cirq.InsertStrategy.NEW_THEN_INLINE,
+        cirq.InsertStrategy.INLINE,
+        cirq.InsertStrategy.EARLIEST,
+    ],
+    ids=lambda strategy: strategy.name,
+)
+def test_identity_after_pickling(strategy: cirq.InsertStrategy):
+    unpickled_strategy = pickle.loads(pickle.dumps(strategy))
+    assert unpickled_strategy is strategy

cirq/ops/pauli_string.py

@@ -41,7 +41,6 @@ from typing import (
 import numpy as np
 import sympy
 
-import cirq
 from cirq import value, protocols, linalg, qis, _compat
 from cirq._doc import document
 from cirq._import import LazyLoader
@@ -496,7 +495,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         """
         qubits = self.qubits if qubits is None else qubits
         factors = [self.get(q, default=identity.I) for q in qubits]
-        if cirq.is_parameterized(self):
+        if protocols.is_parameterized(self):
             raise NotImplementedError('Cannot express as matrix when parameterized')
         assert isinstance(self.coefficient, complex)
         return linalg.kron(self.coefficient, *[protocols.unitary(f) for f in factors])
@@ -981,7 +980,6 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         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`)
@@ -989,23 +987,21 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             # 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)
+            remain: 'cirq.PauliString' = PauliString(
+                *(pauli(q) for q in all_qubits - set(op.qubits) if (pauli := ps.get(q)) is not None)
+            )
 
             # Initialize the conjugation of Pc.
             conjugated: 'cirq.DensePauliString' = (
                 dense_pauli_string.DensePauliString(pauli_mask=[identity.I for _ in op.qubits])
-                * self.coefficient
+                * ps.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):
+            if isinstance(op.gate, clifford_gate.CliffordGate):
                 gate_in_clifford = op.gate
             else:
                 # Convert the clifford gate to CliffordGate type.
@@ -1020,7 +1016,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
             #   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)
+            #     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:
@@ -1100,20 +1096,17 @@ class PauliString(raw_types.Operation, Generic[TKey]):
                 pauli string, instead of before (and so are moving in the
                 opposite direction).
         """
-        pauli_map = dict(self._qubit_pauli_map)
-        should_negate = False
-        for op in ops:
-            if pauli_map.keys().isdisjoint(set(op.qubits)):
-                continue
-            decomposed = _decompose_into_cliffords(op)
-            if not after_to_before:
-                decomposed = decomposed[::-1]
-            for clifford_op in decomposed:
-                if pauli_map.keys().isdisjoint(set(clifford_op.qubits)):
-                    continue
-                should_negate ^= _pass_operation_over(pauli_map, clifford_op, after_to_before)
-        coef = -self._coefficient if should_negate else self.coefficient
-        return PauliString(qubit_pauli_map=pauli_map, coefficient=coef)
+        # TODO(#6946): deprecate this method.
+        # Note: This method is supposed to be replaced by conjugated_by()
+        #  (see #2351 for details).
+        if after_to_before:
+            return self.after(ops)
+
+        if isinstance(ops, gate_operation.GateOperation):
+            return self.before(ops)
+
+        all_ops = list(op_tree.flatten_to_ops(ops))
+        return self.before(all_ops[::-1])
 
     def _is_parameterized_(self) -> bool:
         return protocols.is_parameterized(self.coefficient)
@@ -1179,7 +1172,7 @@ def _try_interpret_as_pauli_string(op: Any):
         if (pauli := gates.get(type(op.gate), None)) is not None:
             exponent = op.gate.exponent  # type: ignore
             if exponent % 2 == 0:
-                return cirq.PauliString()
+                return PauliString()
             if exponent % 2 == 1:
                 return pauli.on(op.qubits[0])
     return None

cirq/ops/pauli_string_phasor_test.py

@@ -163,8 +163,10 @@ def test_pass_operations_over():
     ps_after = cirq.PauliString({q0: cirq.Z, q1: cirq.Y}, -1)
     before = cirq.PauliStringPhasor(ps_before, exponent_neg=0.1)
     after = cirq.PauliStringPhasor(ps_after, exponent_neg=0.1)
-    assert before.pass_operations_over([op]) == after
-    assert after.pass_operations_over([op], after_to_before=True) == before
+    assert before.pass_operations_over([op]).pauli_string == after.pauli_string
+    assert (
+        after.pass_operations_over([op], after_to_before=True).pauli_string == before.pauli_string
+    )
 
 
 def test_extrapolate_effect():

cirq/ops/pauli_string_test.py

@@ -58,19 +58,53 @@ def _small_sample_qubit_pauli_maps():
 
 
 def assert_conjugation(
-    input_ps: cirq.PauliString, ops: cirq.OP_TREE, expected: cirq.PauliString | None
+    input_ps: cirq.PauliString,
+    op: cirq.Operation,
+    expected: cirq.PauliString | None = None,
+    force_checking_unitary=True,
+):
+    """Verifies that conjugating `input_ps` by `op` results in `expected`.
+
+    Also ensures that the unitary representation of the Pauli string is
+    preserved under the conjugation.
+    """
+
+    def _ps_on_qubits(ps: cirq.PauliString, qubits: tuple[cirq.Qid, ...]):
+        """Extracts a sub-PauliString from a given PauliString, restricted to
+        a specified subset of qubits.
+        """
+        pauli_map = {}
+        for q, pauli in ps.items():
+            if q in qubits:
+                pauli_map[q] = pauli
+        return cirq.PauliString(qubit_pauli_map=pauli_map, coefficient=ps.coefficient)
+
+    conjugation = input_ps.conjugated_by(op)
+    if expected is None or force_checking_unitary:
+        # Compares the unitary of the conjugation result and the expected unitary.
+        clifford = cirq.CliffordGate.from_op_list([op], op.qubits)
+        actual_unitary = cirq.unitary(_ps_on_qubits(conjugation, op.qubits).dense(op.qubits))
+        c = cirq.unitary(clifford)
+        expected_unitary = (
+            np.conj(c.T) @ cirq.unitary(_ps_on_qubits(input_ps, op.qubits).dense(op.qubits)) @ c
+        )
+        assert np.allclose(actual_unitary, expected_unitary, atol=1e-8)
+    if expected is not None:
+        assert conjugation == expected
+
+
+def assert_conjugation_multi_ops(
+    input_ps: cirq.PauliString, ops: list[cirq.Operation], expected: cirq.PauliString | None = 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)
+    # conj_by(op_{n-1}).conj_by(op_{n-1}).....conj_by(op_0)
+    conj_in_order = input_ps
+    for op in ops[::-1]:
+        assert_conjugation(conj_in_order, op)
+        conj_in_order = conj_in_order.conjugated_by(op)
+    assert conjugation == conj_in_order
 
 
 def test_eq_ne_hash():
@@ -741,26 +775,31 @@ def test_pass_operations_over_double(shift: int, t_or_f1: bool, t_or_f2: bool, n
     op0 = cirq.PauliInteractionGate(Z, t_or_f1, X, t_or_f2)(q0, q1)
     ps_before = cirq.PauliString(qubit_pauli_map={q0: Z, q2: Y}, coefficient=sign)
     ps_after = cirq.PauliString(qubit_pauli_map={q0: Z, q2: Y}, coefficient=sign)
+    assert_conjugation(ps_before, op0, ps_after, True)
     _assert_pass_over([op0], ps_before, ps_after)
 
     op0 = cirq.PauliInteractionGate(Y, t_or_f1, X, t_or_f2)(q0, q1)
     ps_before = cirq.PauliString({q0: Z, q2: Y}, sign)
-    ps_after = cirq.PauliString({q0: Z, q2: Y, q1: X}, sign)
+    ps_after = cirq.PauliString({q0: Z, q2: Y, q1: X}, -sign if t_or_f2 else sign)
+    assert_conjugation(ps_before, op0, ps_after, True)
     _assert_pass_over([op0], ps_before, ps_after)
 
     op0 = cirq.PauliInteractionGate(Z, t_or_f1, X, t_or_f2)(q0, q1)
     ps_before = cirq.PauliString({q0: Z, q1: Y}, sign)
-    ps_after = cirq.PauliString({q1: Y}, sign)
+    ps_after = cirq.PauliString({q1: Y}, -sign if t_or_f1 else sign)
+    assert_conjugation(ps_before, op0, ps_after, True)
     _assert_pass_over([op0], ps_before, ps_after)
 
     op0 = cirq.PauliInteractionGate(Y, t_or_f1, X, t_or_f2)(q0, q1)
     ps_before = cirq.PauliString({q0: Z, q1: Y}, sign)
     ps_after = cirq.PauliString({q0: X, q1: Z}, -1 if neg ^ t_or_f1 ^ t_or_f2 else +1)
+    assert_conjugation(ps_before, op0, ps_after, True)
     _assert_pass_over([op0], ps_before, ps_after)
 
     op0 = cirq.PauliInteractionGate(X, t_or_f1, X, t_or_f2)(q0, q1)
     ps_before = cirq.PauliString({q0: Z, q1: Y}, sign)
     ps_after = cirq.PauliString({q0: Y, q1: Z}, +1 if neg ^ t_or_f1 ^ t_or_f2 else -1)
+    assert_conjugation(ps_before, op0, ps_after, True)
     _assert_pass_over([op0], ps_before, ps_after)
 
 
@@ -774,7 +813,9 @@ def test_pass_operations_over_cz():
 
 def test_pass_operations_over_no_common_qubits():
     class ExampleGate(cirq.testing.SingleQubitGate):
-        pass
+
+        def _decompose_(self, qubits):
+            return cirq.X(qubits[0])
 
     q0, q1 = _make_qubits(2)
     op0 = ExampleGate()(q1)
@@ -786,7 +827,11 @@ def test_pass_operations_over_no_common_qubits():
 def test_pass_unsupported_operations_over():
     (q0,) = _make_qubits(1)
     pauli_string = cirq.PauliString({q0: cirq.X})
-    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.',
+    ):
         pauli_string.pass_operations_over([cirq.T(q0)])
 
 
@@ -1523,8 +1568,8 @@ def test_conjugated_by_clifford_composite():
 def test_conjugated_by_move_into_uninvolved():
     a, b, c, d = cirq.LineQubit.range(4)
     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))
+    assert_conjugation_multi_ops(ps, [cirq.SWAP(c, d), cirq.SWAP(b, c)], cirq.X(a) * cirq.Z(d))
+    assert_conjugation_multi_ops(ps, [cirq.SWAP(b, c), cirq.SWAP(c, d)], cirq.X(a) * cirq.Z(c))
 
 
 def test_conjugated_by_common_single_qubit_gates():
@@ -1549,7 +1594,7 @@ def test_conjugated_by_common_single_qubit_gates():
             # 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)
+            assert_conjugation(p(a), g(a))
 
 
 def test_conjugated_by_common_two_qubit_gates():
@@ -1580,7 +1625,7 @@ def test_conjugated_by_common_two_qubit_gates():
                 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)
+                assert_conjugation(p, g.on(a, b))
 
 
 def test_conjugated_by_ordering():
@@ -1602,7 +1647,7 @@ def test_pass_operations_over_ordering():
 
     a, b = cirq.LineQubit.range(2)
     inp = cirq.Z(b)
-    out1 = inp.pass_operations_over([OrderSensitiveGate().on(a, b)])
+    out1 = inp.pass_operations_over(OrderSensitiveGate().on(a, b))
     out2 = inp.pass_operations_over([cirq.CNOT(a, b), cirq.Y(a) ** -0.5])
     out3 = inp.pass_operations_over([cirq.CNOT(a, b)]).pass_operations_over([cirq.Y(a) ** -0.5])
     assert out1 == out2 == out3 == cirq.X(a) * cirq.Z(b)
@@ -1618,7 +1663,7 @@ def test_pass_operations_over_ordering_reversed():
 
     a, b = cirq.LineQubit.range(2)
     inp = cirq.X(a) * cirq.Z(b)
-    out1 = inp.pass_operations_over([OrderSensitiveGate().on(a, b)], after_to_before=True)
+    out1 = inp.pass_operations_over(OrderSensitiveGate().on(a, b), after_to_before=True)
     out2 = inp.pass_operations_over([cirq.Y(a) ** -0.5, cirq.CNOT(a, b)], after_to_before=True)
     out3 = inp.pass_operations_over([cirq.Y(a) ** -0.5], after_to_before=True).pass_operations_over(
         [cirq.CNOT(a, b)], after_to_before=True

{cirq_core-1.5.0.dev20250312165047.dist-info → cirq_core-1.5.0.dev20250312231723.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20250312165047
+Version: 1.5.0.dev20250312231723
 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.dev20250312165047.dist-info → cirq_core-1.5.0.dev20250312231723.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=VQxk2g1sWEn_8YXUP8gbpf7HeQHJhWO6-aFrAf1Sy4M,1206
-cirq/_version_test.py,sha256=vIpq3Juh3HROax8NXtDNZ9YSSXCWmcqmoYArhPoIYIc,147
+cirq/_version.py,sha256=z3PMGsFFc9loMC8ptHlwdYk8UGjhaVuEedK4uq5i-Yk,1206
+cirq/_version_test.py,sha256=BZSiO6dH779EPZbO1948wunnJ0f4MFOYnuUlL1Ax8ps,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
@@ -22,8 +22,8 @@ cirq/circuits/circuit_operation_test.py,sha256=SFyM12Ky7-OVwl-jK3OTMMN0DD5hR6tWf
 cirq/circuits/circuit_test.py,sha256=AN81b3nvLGOshSaBIDt4-7lghr1MmFtdTa2XePUll6I,163314
 cirq/circuits/frozen_circuit.py,sha256=qSbLHqIszCbVipNZQy4N829v_mWf8N2926cYRzpxGqE,9243
 cirq/circuits/frozen_circuit_test.py,sha256=rHyii8hLhOQ6jdA8dC1OcYPGnyeBC4uY5Q53XspkkCk,4133
-cirq/circuits/insert_strategy.py,sha256=L0OLXuo24TtBfdJGOAG2PsVDMrbvQl4iN5lUk6IPuyo,2851
-cirq/circuits/insert_strategy_test.py,sha256=dgz13_ssa_GWqzzx5W4G4sJJw4SUHC3-g3K0_Z4TRiA,686
+cirq/circuits/insert_strategy.py,sha256=JU_KPe74P3OpbVQei5iDPgEpOjpts5JFKXU5Xy1QYHE,3211
+cirq/circuits/insert_strategy_test.py,sha256=LVtUECfTe59tYO2piuD1kCA6lhI7ioerF7tp2cQ3bnk,1136
 cirq/circuits/moment.py,sha256=Sv1Xxo1LIChH0Da2iHegbthOWd2Ibq0fsnj5ZrqqEkQ,26191
 cirq/circuits/moment_test.py,sha256=oNHNXhiPEoCKbzeh16tRwiW1qZWlg4X2O_uiVDP1D58,27375
 cirq/circuits/optimization_pass.py,sha256=uw3ne0-ebZo6GNjwfQMuQ3b5u9RCgyaXRfhpbljlxao,6468
@@ -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=sGs0TZt1mtGUarDphJkTkNvKppdV1mB67eSJkKwQiug,70032
+cirq/ops/pauli_string.py,sha256=mTVfWcqhypF7yQ3EkdHPMrtbJIvCYSBq5RRfA5Q83eg,69675
 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_phasor_test.py,sha256=BzmlFH5p-15kxEwLFrrwGaG3JtARZq8gXz2NZPmUfDk,27864
 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=sE2Kje6qmHJzhdVja3fa3Er8g3XJ8l_8hzjgioSFIn4,75742
+cirq/ops/pauli_string_test.py,sha256=JlS0nxddL0L3uv6-kjT7RgSaiN2ME0j-XcLulQL0JTg,77371
 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
@@ -1204,8 +1204,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.dev20250312165047.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250312165047.dist-info/METADATA,sha256=_LRbqdYXqIYKyRB_MVfTZb42-79oHf3ir-6JfSSmte8,4817
-cirq_core-1.5.0.dev20250312165047.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250312165047.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250312165047.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250312231723.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250312231723.dist-info/METADATA,sha256=4CnLvSMX4vKnQBmMMDqbH9HTeUbDczPIDuyLZa0eJsI,4817
+cirq_core-1.5.0.dev20250312231723.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250312231723.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250312231723.dist-info/RECORD,,