cirq-core 1.5.0.dev20250122193351__py3-none-any.whl → 1.5.0.dev20250123022814__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.dev20250122193351"
+__version__ = "1.5.0.dev20250123022814"

cirq/_version_test.py

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

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/op_tree.py

@@ -16,7 +16,6 @@
 """
 
 from typing import Callable, Iterable, Iterator, NoReturn, Union, TYPE_CHECKING
-from typing_extensions import Protocol
 
 from cirq._doc import document
 from cirq._import import LazyLoader
@@ -28,32 +27,7 @@ if TYPE_CHECKING:
 moment = LazyLoader("moment", globals(), "cirq.circuits.moment")
 
 
-class OpTree(Protocol):
-    """The recursive type consumed by circuit builder methods.
-
-    An OpTree is a type protocol, satisfied by anything that can be recursively
-    flattened into Operations. We also define the Union type OP_TREE which
-    can be an OpTree or just a single Operation.
-
-    For example:
-    - An Operation is an OP_TREE all by itself.
-    - A list of operations is an OP_TREE.
-    - A list of tuples of operations is an OP_TREE.
-    - A list with a mix of operations and lists of operations is an OP_TREE.
-    - A generator yielding operations is an OP_TREE.
-
-    Note: once mypy supports recursive types this could be defined as an alias:
-
-    OP_TREE = Union[Operation, Iterable['OP_TREE']]
-
-    See: https://github.com/python/mypy/issues/731
-    """
-
-    def __iter__(self) -> Iterator[Union[Operation, 'OpTree']]:
-        pass
-
-
-OP_TREE = Union[Operation, OpTree]
+OP_TREE = Union[Operation, Iterable['OP_TREE']]
 document(
     OP_TREE,
     """An operation or nested collections of operations.

cirq/transformers/analytical_decompositions/quantum_shannon_decomposition.py

@@ -19,7 +19,7 @@ Based on:
 Synthesis of Quantum Logic Circuits. Tech. rep. 2006,
 https://arxiv.org/abs/quant-ph/0406176
 """
-from typing import List, Callable, TYPE_CHECKING
+from typing import Callable, Iterable, List, TYPE_CHECKING
 
 from scipy.linalg import cossin
 
@@ -38,12 +38,11 @@ from cirq.circuits.frozen_circuit import FrozenCircuit
 
 if TYPE_CHECKING:
     import cirq
-    from cirq.ops import op_tree
 
 
 def quantum_shannon_decomposition(
     qubits: 'List[cirq.Qid]', u: np.ndarray, atol: float = 1e-8
-) -> 'op_tree.OpTree':
+) -> Iterable['cirq.Operation']:
     """Decomposes n-qubit unitary 1-q, 2-q and GlobalPhase gates, preserving global phase.
 
     The gates used are CX/YPow/ZPow/CNOT/GlobalPhase/CZ/PhasedXZGate/PhasedXPowGate.
@@ -141,7 +140,7 @@ def quantum_shannon_decomposition(
     yield from _msb_demuxer(qubits, u1, u2)
 
 
-def _single_qubit_decomposition(qubit: 'cirq.Qid', u: np.ndarray) -> 'op_tree.OpTree':
+def _single_qubit_decomposition(qubit: 'cirq.Qid', u: np.ndarray) -> Iterable['cirq.Operation']:
     """Decomposes single-qubit gate, and returns list of operations, keeping phase invariant.
 
     Args:
@@ -186,7 +185,7 @@ def _single_qubit_decomposition(qubit: 'cirq.Qid', u: np.ndarray) -> 'op_tree.Op
 
 def _msb_demuxer(
     demux_qubits: 'List[cirq.Qid]', u1: np.ndarray, u2: np.ndarray
-) -> 'op_tree.OpTree':
+) -> Iterable['cirq.Operation']:
     """Demultiplexes a unitary matrix that is multiplexed in its most-significant-qubit.
 
     Decomposition structure:
@@ -249,7 +248,7 @@ def _nth_gray(n: int) -> int:
 
 def _multiplexed_cossin(
     cossin_qubits: 'List[cirq.Qid]', angles: List[float], rot_func: Callable = ops.ry
-) -> 'op_tree.OpTree':
+) -> Iterable['cirq.Operation']:
     """Performs a multiplexed rotation over all qubits in this unitary matrix,
 
     Uses ry and rz multiplexing for quantum shannon decomposition

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.dev20250122193351.dist-info → cirq_core-1.5.0.dev20250123022814.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20250122193351
+Version: 1.5.0.dev20250123022814
 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.dev20250122193351.dist-info → cirq_core-1.5.0.dev20250123022814.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=WFhJmgYICxtpdKSoM9Ddzu3ntb_okVm0AooNMz81zBE,1206
-cirq/_version_test.py,sha256=h5jubeUTqzv-sokoqfTg1Fz-9jU9O4F8vV9KQ88ThCs,147
+cirq/_version.py,sha256=MiLgjEo202Qv-ygfNGqCcnJpmTcjZ4eQLLB5agkLPEc,1206
+cirq/_version_test.py,sha256=g6UUmNCvxGNzi-tf6ybG2bVSS1Q_F47Od5ycp5zbPkA,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
@@ -321,7 +321,7 @@ cirq/ops/mixed_unitary_channel.py,sha256=k3O4ovH3bFs1WnAZc647IgCK8thC5JnTGxsCzjB
 cirq/ops/mixed_unitary_channel_test.py,sha256=x8LIAea2KcutNupnRJ_cLy1kmxhbUh3K3BkZtg3OkKQ,5058
 cirq/ops/named_qubit.py,sha256=niAsH7m32n3lEVIcy1nnVDPkPqk6PY2qlriz7mzgZmk,10006
 cirq/ops/named_qubit_test.py,sha256=mtJVRe4JzFSNckMQJSGCj1P0VBtpGh--6YxKbIEE3TQ,5221
-cirq/ops/op_tree.py,sha256=iXsIFcQCciU7C9SiPxhd_zrp4TBGCsmnqxKDjUl1aEo,6159
+cirq/ops/op_tree.py,sha256=7hcyqhuK41Rg3vDPvRPkCn6G6a_shvmxEQvnYiQfbDw,5277
 cirq/ops/op_tree_test.py,sha256=h4phqrxQwYAfyu8o4f_fLi3WP2kdVuzWqrSCWGLHo_c,5575
 cirq/ops/parallel_gate.py,sha256=duCtDht-HRlYM3V7JmFnB_l2rx5PRqAwyRMjug9kvnM,6318
 cirq/ops/parallel_gate_test.py,sha256=M6o3AyXFQrwyiOTtGxlYH09TbHdjtTxCuMjmn-ALnn0,6298
@@ -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
@@ -1086,7 +1086,7 @@ cirq/transformers/analytical_decompositions/cphase_to_fsim.py,sha256=RDg0wzYa_YX
 cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py,sha256=bwZa0BDclAd1sX3bD-GdNF2MO5DtH7mw2YLppEK0LG0,5568
 cirq/transformers/analytical_decompositions/pauli_string_decomposition.py,sha256=bU9IoY0igVZTmF_wsTdTxAfqPKWyqZ14Gt2AJoK5D_4,4524
 cirq/transformers/analytical_decompositions/pauli_string_decomposition_test.py,sha256=qpFODpCJrE9piYLWR1FzweTn3v80EvLCV-PP2fbHcoE,2112
-cirq/transformers/analytical_decompositions/quantum_shannon_decomposition.py,sha256=beW4G_yE2lGNQEGbItwEa_w7lx0ECmGFZ7bCvMfk3bg,11768
+cirq/transformers/analytical_decompositions/quantum_shannon_decomposition.py,sha256=ZN6qKTdGs-ZLM8uIYhs3iGBQSAkj6_CjqFNiI_EZwBI,11785
 cirq/transformers/analytical_decompositions/quantum_shannon_decomposition_test.py,sha256=E7NM5NzNUVwlTcgzDs18tmnybA4DUVvGl9y6_Geikss,7685
 cirq/transformers/analytical_decompositions/single_qubit_decompositions.py,sha256=iAPdMwHKM1B3mJtQWH-iNjR-VkzhkUDFC23f8kjXY6M,8436
 cirq/transformers/analytical_decompositions/single_qubit_decompositions_test.py,sha256=4GfU6wctBoG-OVFqFOE08xymd5dXzY-doE8ZNpsKohI,12308
@@ -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.dev20250122193351.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250122193351.dist-info/METADATA,sha256=CgeMBbwsI8eAcEZR-fru-N4jHXdUTXfxB9qoPBt4yJM,2105
-cirq_core-1.5.0.dev20250122193351.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250122193351.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250122193351.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250123022814.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250123022814.dist-info/METADATA,sha256=l3DTeYXoz7dLV4htqmUW3xdKr0kGjVt8VtvEEHHXBas,2105
+cirq_core-1.5.0.dev20250123022814.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250123022814.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250123022814.dist-info/RECORD,,