cirq-core 1.5.0.dev20250123021547__py3-none-any.whl → 1.5.0.dev20250124083125__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.dev20250123021547"
+__version__ = "1.5.0.dev20250124083125"

cirq/_version_test.py

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

cirq/circuits/circuit.py

@@ -1769,6 +1769,7 @@ class Circuit(AbstractCircuit):
                 together. This option does not affect later insertions into the
                 circuit.
         """
+        self._placement_cache: Optional[_PlacementCache] = _PlacementCache()
         self._moments: List['cirq.Moment'] = []
 
         # Implementation note: the following cached properties are set lazily and then
@@ -1779,9 +1780,11 @@ class Circuit(AbstractCircuit):
         self._is_measurement: Optional[bool] = None
         self._is_parameterized: Optional[bool] = None
         self._parameter_names: Optional[AbstractSet[str]] = None
-
+        if not contents:
+            return
         flattened_contents = tuple(ops.flatten_to_ops_or_moments(contents))
         if all(isinstance(c, Moment) for c in flattened_contents):
+            self._placement_cache = None
             self._moments[:] = cast(Iterable[Moment], flattened_contents)
             return
         with _compat.block_overlapping_deprecation('.*'):
@@ -1790,18 +1793,21 @@ class Circuit(AbstractCircuit):
             else:
                 self.append(flattened_contents, strategy=strategy)
 
-    def _mutated(self) -> None:
+    def _mutated(self, *, preserve_placement_cache=False) -> None:
         """Clear cached properties in response to this circuit being mutated."""
         self._all_qubits = None
         self._frozen = None
         self._is_measurement = None
         self._is_parameterized = None
         self._parameter_names = None
+        if not preserve_placement_cache:
+            self._placement_cache = None
 
     @classmethod
     def _from_moments(cls, moments: Iterable['cirq.Moment']) -> 'Circuit':
         new_circuit = Circuit()
         new_circuit._moments[:] = moments
+        new_circuit._placement_cache = None
         return new_circuit
 
     def _load_contents_with_earliest_strategy(self, contents: 'cirq.OP_TREE'):
@@ -1823,27 +1829,18 @@ class Circuit(AbstractCircuit):
                 Non-moment entries will be inserted according to the EARLIEST
                 insertion strategy.
         """
-        # These are dicts from the qubit/key to the greatest moment index that has it.
-        qubit_indices: Dict['cirq.Qid', int] = {}
-        mkey_indices: Dict['cirq.MeasurementKey', int] = {}
-        ckey_indices: Dict['cirq.MeasurementKey', int] = {}
+        # PlacementCache holds dicts from the qubit/key to the greatest moment index that has it.
+        placement_cache = cast(_PlacementCache, self._placement_cache)
 
         # We also maintain the dict from moment index to moments/ops that go into it, for use when
         # building the actual moments at the end.
         op_lists_by_index: Dict[int, List['cirq.Operation']] = defaultdict(list)
         moments_by_index: Dict[int, 'cirq.Moment'] = {}
 
-        # For keeping track of length of the circuit thus far.
-        length = 0
-
         # "mop" means current moment-or-operation
         for mop in ops.flatten_to_ops_or_moments(contents):
             # Identify the index of the moment to place this `mop` into.
-            placement_index = get_earliest_accommodating_moment_index(
-                mop, qubit_indices, mkey_indices, ckey_indices, length
-            )
-            length = max(length, placement_index + 1)  # update the length of the circuit thus far
-
+            placement_index = placement_cache.append(mop)
             if isinstance(mop, Moment):
                 moments_by_index[placement_index] = mop
             else:
@@ -1851,7 +1848,7 @@ class Circuit(AbstractCircuit):
 
         # Finally, once everything is placed, we can construct and append the actual moments for
         # each index.
-        for i in range(length):
+        for i in range(placement_cache._length):
             if i in moments_by_index:
                 self._moments.append(moments_by_index[i].with_operations(op_lists_by_index[i]))
             else:
@@ -1899,6 +1896,7 @@ class Circuit(AbstractCircuit):
         """Return a copy of this circuit."""
         copied_circuit = Circuit()
         copied_circuit._moments = self._moments[:]
+        copied_circuit._placement_cache = None
         return copied_circuit
 
     # pylint: disable=function-redefined
@@ -2172,20 +2170,25 @@ class Circuit(AbstractCircuit):
         """
         # limit index to 0..len(self._moments), also deal with indices smaller 0
         k = max(min(index if index >= 0 else len(self._moments) + index, len(self._moments)), 0)
+        if strategy != InsertStrategy.EARLIEST or index != len(self._moments):
+            self._placement_cache = None
         for moment_or_op in list(ops.flatten_to_ops_or_moments(moment_or_operation_tree)):
+            if self._placement_cache:
+                p = self._placement_cache.append(moment_or_op)
+            elif isinstance(moment_or_op, Moment):
+                p = k
+            else:
+                p = self._pick_or_create_inserted_op_moment_index(k, moment_or_op, strategy)
             if isinstance(moment_or_op, Moment):
-                self._moments.insert(k, moment_or_op)
-                k += 1
+                self._moments.insert(p, moment_or_op)
+            elif p == len(self._moments):
+                self._moments.append(Moment(moment_or_op))
             else:
-                op = moment_or_op
-                p = self._pick_or_create_inserted_op_moment_index(k, op, strategy)
-                while p >= len(self._moments):
-                    self._moments.append(Moment())
-                self._moments[p] = self._moments[p].with_operation(op)
-                k = max(k, p + 1)
-                if strategy is InsertStrategy.NEW_THEN_INLINE:
-                    strategy = InsertStrategy.INLINE
-        self._mutated()
+                self._moments[p] = self._moments[p].with_operation(moment_or_op)
+            k = max(k, p + 1)
+            if strategy is InsertStrategy.NEW_THEN_INLINE:
+                strategy = InsertStrategy.INLINE
+        self._mutated(preserve_placement_cache=True)
         return k
 
     def insert_into_range(self, operations: 'cirq.OP_TREE', start: int, end: int) -> int:
@@ -2853,7 +2856,7 @@ def get_earliest_accommodating_moment_index(
     Args:
         moment_or_operation: The moment operation in question.
         qubit_indices: A dictionary mapping qubits to the latest moments that address them.
-        mkey_indices: A dictionary mapping measureent keys to the latest moments that address them.
+        mkey_indices: A dictionary mapping measurement keys to the latest moments that address them.
         ckey_indices: A dictionary mapping control keys to the latest moments that address them.
         length: The length of the circuit that we are trying to insert a moment or operation into.
             Should probably be equal to the maximum of the values in `qubit_indices`,
@@ -2897,7 +2900,7 @@ def get_earliest_accommodating_moment_index(
         if mop_ckeys:
             last_conflict = max(last_conflict, *[mkey_indices.get(key, -1) for key in mop_ckeys])
 
-    # The index of the moment to place this moment or operaton ("mop") into.
+    # The index of the moment to place this moment or operation ("mop") into.
     mop_index = last_conflict + 1
 
     # Update our dicts with data from this `mop` placement. Note `mop_index` will always be greater
@@ -2910,3 +2913,52 @@ def get_earliest_accommodating_moment_index(
         ckey_indices[key] = mop_index
 
     return mop_index
+
+
+class _PlacementCache:
+    """Maintains qubit and cbit indices for quick op placement.
+
+    Here, we keep track of the greatest moment that contains each qubit,
+    measurement key, and control key, and append operations to the moment after
+    the maximum of these. This avoids having to iterate backwards, checking
+    each moment one at a time.
+
+    It is only valid for `append` operations, and if any other insert strategy
+    is used, or if any operation is added to the circuit without notifying the
+    cache, then the cache must be invalidated for the circuit or rebuilt from
+    scratch. Future improvements may ease this restriction.
+    """
+
+    def __init__(self) -> None:
+        # These are dicts from the qubit/key to the greatest moment index that has it.
+        self._qubit_indices: Dict['cirq.Qid', int] = {}
+        self._mkey_indices: Dict['cirq.MeasurementKey', int] = {}
+        self._ckey_indices: Dict['cirq.MeasurementKey', int] = {}
+
+        # For keeping track of length of the circuit thus far.
+        self._length = 0
+
+    def append(self, moment_or_operation: Union['cirq.Moment', 'cirq.Operation']) -> int:
+        """Find placement for moment/operation and update cache.
+
+        Determines the placement index of the provided operation, assuming
+        EARLIEST (append) strategy, and assuming that the internal cache
+        correctly represents the circuit. It then updates the cache and returns
+        the placement index.
+
+        Args:
+            moment_or_operation: The moment or operation to append.
+
+        Returns:
+            The index at which the moment/operation should be placed.
+        """
+        # Identify the index of the moment to place this into.
+        index = get_earliest_accommodating_moment_index(
+            moment_or_operation,
+            self._qubit_indices,
+            self._mkey_indices,
+            self._ckey_indices,
+            self._length,
+        )
+        self._length = max(self._length, index + 1)
+        return index

cirq/circuits/circuit_test.py

@@ -4845,18 +4845,36 @@ global phase:   0.5π
 def test_create_speed():
     # Added in https://github.com/quantumlib/Cirq/pull/5332
     # Previously this took ~30s to run. Now it should take ~150ms. However the coverage test can
-    # run this slowly, so allowing 2 sec to account for things like that. Feel free to increase the
+    # run this slowly, so allowing 4 sec to account for things like that. Feel free to increase the
     # buffer time or delete the test entirely if it ends up causing flakes.
-    #
-    # Updated in https://github.com/quantumlib/Cirq/pull/5756
-    # After several tiny overtime failures of the GitHub CI Pytest MacOS (3.7)
-    # the timeout was increased to 4 sec.  A more thorough investigation or test
-    # removal should be considered if this continues to time out.
     qs = 100
     moments = 500
     xs = [cirq.X(cirq.LineQubit(i)) for i in range(qs)]
-    opa = [xs[i] for i in range(qs) for _ in range(moments)]
+    ops = [xs[i] for i in range(qs) for _ in range(moments)]
+    t = time.perf_counter()
+    c = cirq.Circuit(ops)
+    duration = time.perf_counter() - t
+    assert len(c) == moments
+    assert duration < 4
+
+
+def test_append_speed():
+    # Previously this took ~17s to run. Now it should take ~150ms. However the coverage test can
+    # run this slowly, so allowing 5 sec to account for things like that. Feel free to increase the
+    # buffer time or delete the test entirely if it ends up causing flakes.
+    #
+    # The `append` improvement mainly helps for deep circuits. It is less useful for wide circuits
+    # because the Moment (immutable) needs verified and reconstructed each time an op is added.
+    qs = 2
+    moments = 10000
+    xs = [cirq.X(cirq.LineQubit(i)) for i in range(qs)]
+    c = cirq.Circuit()
     t = time.perf_counter()
-    c = cirq.Circuit(opa)
+    # Iterating with the moments in the inner loop highlights the improvement: when filling in the
+    # second qubit, we no longer have to search backwards from moment 10000 for a placement index.
+    for q in range(qs):
+        for _ in range(moments):
+            c.append(xs[q])
+    duration = time.perf_counter() - t
     assert len(c) == moments
-    assert time.perf_counter() - t < 4
+    assert duration < 5

cirq/contrib/acquaintance/executor.py

@@ -75,6 +75,7 @@ class ExecutionStrategy(metaclass=abc.ABCMeta):
         strategy = StrategyExecutorTransformer(self)
         final_circuit = strategy(input_circuit, **kwargs)
         input_circuit._moments = final_circuit._moments
+        input_circuit._placement_cache = final_circuit._placement_cache
         return strategy.mapping
 
 

cirq/ops/phased_iswap_gate.py

@@ -93,15 +93,14 @@ class PhasedISwapPowGate(eigen_gate.EigenGate):
         }
 
     def _value_equality_values_cls_(self):
-        if self.phase_exponent == 0:
-            return swap_gates.ISwapPowGate
         return PhasedISwapPowGate
 
     def _value_equality_values_(self):
-        if self.phase_exponent == 0:
-            return self._iswap._value_equality_values_()
         return (self.phase_exponent, *self._iswap._value_equality_values_())
 
+    def _value_equality_approximate_values_(self):
+        return (self.phase_exponent, *self._iswap._value_equality_approximate_values_())
+
     def _is_parameterized_(self) -> bool:
         return protocols.is_parameterized(self._iswap) or protocols.is_parameterized(
             self._phase_exponent

cirq/ops/phased_iswap_gate_test.py

@@ -34,11 +34,10 @@ def test_phased_iswap_init():
 
 def test_phased_iswap_equality():
     eq = cirq.testing.EqualsTester()
-    eq.add_equality_group(cirq.PhasedISwapPowGate(phase_exponent=0, exponent=0.4), cirq.ISWAP**0.4)
-    eq.add_equality_group(
-        cirq.PhasedISwapPowGate(phase_exponent=0, exponent=0.4, global_shift=0.3),
-        cirq.ISwapPowGate(global_shift=0.3) ** 0.4,
-    )
+    eq.add_equality_group(cirq.PhasedISwapPowGate(phase_exponent=0, exponent=0.4))
+    eq.add_equality_group(cirq.ISWAP**0.4)
+    eq.add_equality_group(cirq.PhasedISwapPowGate(phase_exponent=0, exponent=0.4, global_shift=0.3))
+    eq.add_equality_group(cirq.ISwapPowGate(global_shift=0.3) ** 0.4)
 
 
 def test_repr():
@@ -204,3 +203,20 @@ def test_givens_rotation_equivalent_circuit():
 @pytest.mark.parametrize('angle_rads', (-np.pi / 5, 0.4, 2, np.pi))
 def test_givens_rotation_has_consistent_protocols(angle_rads):
     cirq.testing.assert_implements_consistent_protocols(cirq.givens(angle_rads))
+
+
+def test_approx_eq():
+    gate0 = cirq.PhasedISwapPowGate(phase_exponent=0)
+    gate1 = cirq.PhasedISwapPowGate(phase_exponent=1e-12)
+    gate2 = cirq.PhasedISwapPowGate(phase_exponent=2e-12)
+    gate3 = cirq.PhasedISwapPowGate(phase_exponent=0.345)
+    gate4 = cirq.ISwapPowGate()
+
+    assert cirq.approx_eq(gate1, gate2)
+    assert cirq.approx_eq(gate1, gate0)
+    assert not cirq.approx_eq(gate1, gate3)
+    assert not cirq.approx_eq(gate0, gate4)
+
+    assert cirq.equal_up_to_global_phase(gate1, gate2)
+    assert cirq.equal_up_to_global_phase(gate1, gate0)
+    assert not cirq.equal_up_to_global_phase(gate1, gate3)

cirq/transformers/transformer_primitives.py

@@ -196,37 +196,16 @@ def _map_operations_impl(
         return mapped_ops
 
     new_moments: List[List['cirq.Operation']] = []
-
-    # Keep track of the latest time index for each qubit, measurement key, and control key.
-    qubit_time_index: Dict['cirq.Qid', int] = {}
-    measurement_time_index: Dict['cirq.MeasurementKey', int] = {}
-    control_time_index: Dict['cirq.MeasurementKey', int] = {}
-
-    # New mapped operations in the current moment should be inserted after `last_moment_time_index`.
-    last_moment_time_index = -1
-
     for idx, moment in enumerate(circuit):
-        if wrap_in_circuit_op:
-            new_moments.append([])
+        curr_moments: List[List['cirq.Operation']] = [[]] if wrap_in_circuit_op else []
+        placement_cache = circuits.circuit._PlacementCache()
         for op in moment:
             mapped_ops = apply_map_func(op, idx)
-
             for mapped_op in mapped_ops:
-                # Identify the earliest moment that can accommodate this op.
-                placement_index = circuits.circuit.get_earliest_accommodating_moment_index(
-                    mapped_op, qubit_time_index, measurement_time_index, control_time_index
-                )
-                placement_index = max(placement_index, last_moment_time_index + 1)
-                new_moments.extend([[] for _ in range(placement_index - len(new_moments) + 1)])
-                new_moments[placement_index].append(mapped_op)
-                for qubit in mapped_op.qubits:
-                    qubit_time_index[qubit] = placement_index
-                for key in protocols.measurement_key_objs(mapped_op):
-                    measurement_time_index[key] = placement_index
-                for key in protocols.control_keys(mapped_op):
-                    control_time_index[key] = placement_index
-
-        last_moment_time_index = len(new_moments) - 1
+                placement_index = placement_cache.append(mapped_op)
+                curr_moments.extend([[] for _ in range(placement_index - len(curr_moments) + 1)])
+                curr_moments[placement_index].append(mapped_op)
+        new_moments.extend(curr_moments)
 
     return _create_target_circuit_type([circuits.Moment(moment) for moment in new_moments], circuit)
 

{cirq_core-1.5.0.dev20250123021547.dist-info → cirq_core-1.5.0.dev20250124083125.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20250123021547
+Version: 1.5.0.dev20250124083125
 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.dev20250123021547.dist-info → cirq_core-1.5.0.dev20250124083125.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=u_m_cD2d_HEazuNrgNctCw4iZELrg_GWcnlaOeAL_2U,1206
-cirq/_version_test.py,sha256=VDv1tmDBN8bYaxwNfmiKf7uPAbAP66EmrAPvGJVRtXY,147
+cirq/_version.py,sha256=JHzy1sBc8gxV0tc2C6keMIRShBtpgrGSEp7liraq2DU,1206
+cirq/_version_test.py,sha256=6gCIKSIrQjkIsGLbNAytGUQNjpfyatTFUpwJ_OmIJj8,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
@@ -16,10 +16,10 @@ cirq/circuits/_box_drawing_character_data.py,sha256=QLoCXwcLL7091RdxEKO259goxt4R
 cirq/circuits/_box_drawing_character_data_test.py,sha256=XO94z0piwZRHaNZHTf-5tKHQ4MKcDruMeRIKdT8GbYA,1624
 cirq/circuits/_bucket_priority_queue.py,sha256=hxFuii2fKD8G6EKT_aVLEsA7FmSfqFXPwIbA0KsoSC4,6745
 cirq/circuits/_bucket_priority_queue_test.py,sha256=t6u_hG7K2e2WKWrgCsKxNRtp4ghKwiCrp0_WSY0W25k,5288
-cirq/circuits/circuit.py,sha256=mSchbaJudEfwqpLj6x0He54d8GhyiE7nqA2RTx8Zw6c,115851
+cirq/circuits/circuit.py,sha256=nbWC95tzQlm69JmvFJdJMwzDOia_s0pah8tH4i9u1Ug,118173
 cirq/circuits/circuit_operation.py,sha256=MaQ6fPt1HctEE31fVaUDtl9MqOmoTyt3m2HYeGCdIaM,35440
 cirq/circuits/circuit_operation_test.py,sha256=7ezTwTY2RaAchjfXOJythVrxs6Rom317gC0AUBe0GVM,45259
-cirq/circuits/circuit_test.py,sha256=1YMXK7wHcct-HK7MKH8lE63pQQ80-jCghVAsG0DsXpU,160524
+cirq/circuits/circuit_test.py,sha256=BZjwavIekWR2hgG1yV0Acgt7-Q05cOjugozrLgYdx7k,161268
 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
@@ -40,7 +40,7 @@ cirq/contrib/acquaintance/bipartite.py,sha256=iEElNihoQ0m1pt5f0bPOIubPnRqqbPJSEh
 cirq/contrib/acquaintance/bipartite_test.py,sha256=hjdJfjDsd2pnUdpph5n9kTWEclSvocsAEmnTbBT21Ak,15648
 cirq/contrib/acquaintance/devices.py,sha256=1hWW9_WF5TZQXFMu9-yXNTk3GfSETyjikNboPQvPYWk,3031
 cirq/contrib/acquaintance/devices_test.py,sha256=icl_9SOp8PuZu7msfW5H7zP7_-zfTwTjyPPkajDu-w4,1088
-cirq/contrib/acquaintance/executor.py,sha256=cdj8U9Wiv8HAupU_hezEaMbeFSq1nMgqPfWrk-8XsrI,8609
+cirq/contrib/acquaintance/executor.py,sha256=ZGPWcEVYAdkqA9rvECsp7WFgxYC_wAvfE6HKNqzT7AM,8681
 cirq/contrib/acquaintance/executor_test.py,sha256=ir-LKuQTfHm5WCcjmLriJ8qCT89YnltLpFx89Q3bF_I,7837
 cirq/contrib/acquaintance/gates.py,sha256=YSsxvvyXQQOsEOr9lKdy0s00w6EAN7mWbu3Y0zjHEU8,13545
 cirq/contrib/acquaintance/gates_test.py,sha256=5FVX7zAtZSUqDPNsXk_Wm7LwDmHIApzgNhjAIX1IQBM,15010
@@ -343,8 +343,8 @@ cirq/ops/pauli_sum_exponential.py,sha256=n3fhKWJVMudzGuOcdPHskVNx3fHE2MAblVdkzbD
 cirq/ops/pauli_sum_exponential_test.py,sha256=wVnJ3FSpEimHT8ERVkmljALrgSuuDYo6GRg91uJ7ztk,5370
 cirq/ops/permutation_gate.py,sha256=2h8n76N2M3nu5MA8JkRQgVLByq5cOEluKUN042ClSRs,4196
 cirq/ops/permutation_gate_test.py,sha256=SwXRgsZNLn5jnGhfcKPJ0J0CIssNzElbFaqylV2TXD8,3281
-cirq/ops/phased_iswap_gate.py,sha256=UVg7-aPKxKU984CaKfEVZveu_nC4xGfNlUGx17a43AY,9023
-cirq/ops/phased_iswap_gate_test.py,sha256=oH3RQ8tlSD0sU5Cf3M0uR92y3M1Xd7Yk3ayOoca9Neg,6708
+cirq/ops/phased_iswap_gate.py,sha256=Q-1PuSc4F3gsZL9UUN8EgrO31Ix6mA-7HoUIndvePbk,8990
+cirq/ops/phased_iswap_gate_test.py,sha256=tB1MqH8Y0Kgr0QIxs1kq1yl2g0mKYI7Q_AaadBhFe2U,7360
 cirq/ops/phased_x_gate.py,sha256=qjlkdbj7SWMvgTJkTqEqsLe2XDgAGioA6ayanns-apg,9983
 cirq/ops/phased_x_gate_test.py,sha256=IpY-Z-MsqtYbyIEdxWu1NqgAJF2B7nddxPc2Hxafr4s,10202
 cirq/ops/phased_x_z_gate.py,sha256=uVmROoiKYxGPs_QZbpwoi7EmVHV4J2-LRa7jyLeIbCM,11563
@@ -1075,7 +1075,7 @@ cirq/transformers/synchronize_terminal_measurements.py,sha256=p061MYYglY6HhWYYkF
 cirq/transformers/synchronize_terminal_measurements_test.py,sha256=VTiw5S3s_Y31qR7ME8Mzv50LdJ_6M3DOtgwvtziQzPI,7742
 cirq/transformers/transformer_api.py,sha256=f95sfOr-KYXLt4yxAaFXoG0-oEc8IKApzG4pyXsm3YY,16956
 cirq/transformers/transformer_api_test.py,sha256=f-Vup0VCUvTqJKm5kWHf6xet7sFTerLMGYzJHy8Rc5s,13045
-cirq/transformers/transformer_primitives.py,sha256=ZiQjYLfksI8ZxqvTvhUN0R9X1WvKEYwAo6NymoKGvzw,37658
+cirq/transformers/transformer_primitives.py,sha256=LbGM_d5xqa1BR-juA08r4FkeWK9JqSU9yISeu4u6WkI,36661
 cirq/transformers/transformer_primitives_test.py,sha256=5N23aI-DGRBj2T6Xd7VUiLBXWU6pgNsvmjZXJ3wwous,41725
 cirq/transformers/analytical_decompositions/__init__.py,sha256=hMsoQSQtSvEn5mNohSvGPjsmf58VN4jzmIFnchVhZi8,3760
 cirq/transformers/analytical_decompositions/clifford_decomposition.py,sha256=DsuuP91pm2dX0CO4rWwmJAJyAfuXMcA1UJK0g8krp7k,6726
@@ -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.dev20250123021547.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250123021547.dist-info/METADATA,sha256=kMZkbns_CNygokLXred5EMsE3Xh9osu8fFnFNxuqxQE,2105
-cirq_core-1.5.0.dev20250123021547.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250123021547.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250123021547.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250124083125.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250124083125.dist-info/METADATA,sha256=Ygd4x48Fml3TYoTGIMPuS7MJxEz0XEbqwsp-G6E-Umw,2105
+cirq_core-1.5.0.dev20250124083125.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250124083125.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250124083125.dist-info/RECORD,,