cirq-core 1.6.0.dev20250507172716__py3-none-any.whl → 1.6.0.dev20250507225534__py3-none-any.whl

cirq/__init__.py

@@ -363,6 +363,7 @@ from cirq.transformers import (
     eject_z as eject_z,
     expand_composite as expand_composite,
     HardCodedInitialMapper as HardCodedInitialMapper,
+    index_tags as index_tags,
     is_negligible_turn as is_negligible_turn,
     LineInitialMapper as LineInitialMapper,
     MappingManager as MappingManager,
@@ -385,6 +386,7 @@ from cirq.transformers import (
     prepare_two_qubit_state_using_sqrt_iswap as prepare_two_qubit_state_using_sqrt_iswap,
     quantum_shannon_decomposition as quantum_shannon_decomposition,
     RouteCQC as RouteCQC,
+    remove_tags as remove_tags,
     routed_circuit_with_mapping as routed_circuit_with_mapping,
     SqrtIswapTargetGateset as SqrtIswapTargetGateset,
     single_qubit_matrix_to_gates as single_qubit_matrix_to_gates,

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.6.0.dev20250507172716"
+__version__ = "1.6.0.dev20250507225534"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.6.0.dev20250507172716"
+    assert cirq.__version__ == "1.6.0.dev20250507225534"

cirq/contrib/paulistring/clifford_optimize.py

@@ -65,7 +65,7 @@ def clifford_optimized_circuit(circuit: circuits.Circuit, atol: float = 1e-8) ->
                     furthest_i = i
                 break
             if cont_cond == CONTINUE:
-                modified_op = modified_op.pass_operations_over([op], after_to_before=True)
+                modified_op = modified_op.conjugated_by(protocols.inverse(op))
             num_passed_over += 1
             if len(modified_op.pauli_string) == 1:
                 furthest_op = modified_op
@@ -122,7 +122,7 @@ def clifford_optimized_circuit(circuit: circuits.Circuit, atol: float = 1e-8) ->
                 all_ops.insert(merge_i + 1, part_cliff_gate(qubit))
             elif isinstance(other_op, ops.PauliStringPhasor):
                 # Pass over a non-Clifford gate
-                mod_op = other_op.pass_operations_over([part_cliff_gate(qubit)])
+                mod_op = other_op.conjugated_by([part_cliff_gate(qubit)])
                 all_ops[merge_i] = mod_op
                 all_ops.insert(merge_i + 1, part_cliff_gate(qubit))
             elif merge_i > start_i + 1 and num_passed > 0:

cirq/contrib/paulistring/recombine.py

@@ -53,7 +53,7 @@ def _sorted_best_string_placements(
             ):
                 # This is as far through as this Pauli string can move
                 break
-            string_op = string_op.pass_operations_over([out_op], after_to_before=True)
+            string_op = string_op.conjugated_by(protocols.inverse(out_op))
             curr = (string_op, i + 1, possible_node)
             if sort_key(curr) > sort_key(node_max):
                 node_max = curr

cirq/contrib/paulistring/separate.py

@@ -89,8 +89,9 @@ def pauli_string_half(circuit: circuits.Circuit) -> circuits.Circuit:
 
 
 def _pull_non_clifford_before(circuit: circuits.Circuit) -> Iterator[ops.OP_TREE]:
-    def _iter_ops_range_reversed(moment_end):
-        for i in reversed(range(moment_end)):
+
+    def _iter_ops_range(moment_end):
+        for i in range(moment_end):
             moment = circuit[i]
             for op in moment.operations:
                 if not isinstance(op, ops.PauliStringPhasor):
@@ -99,5 +100,5 @@ def _pull_non_clifford_before(circuit: circuits.Circuit) -> Iterator[ops.OP_TREE
     for i, moment in enumerate(circuit):
         for op in moment.operations:
             if isinstance(op, ops.PauliStringPhasor):
-                ops_to_cross = _iter_ops_range_reversed(i)
-                yield op.pass_operations_over(ops_to_cross)
+                ops_to_cross = _iter_ops_range(i)
+                yield op.conjugated_by(ops_to_cross)

cirq/ops/pauli_string.py

@@ -45,6 +45,7 @@ import numpy as np
 import sympy
 
 from cirq import _compat, linalg, protocols, qis, value
+from cirq._compat import deprecated
 from cirq._doc import document
 from cirq._import import LazyLoader
 from cirq.ops import (
@@ -1070,9 +1071,10 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         """
         return self.conjugated_by(ops)
 
+    @deprecated(deadline="v2.0", fix="Use conjuagetd_by()/before()/after() instead.")
     def pass_operations_over(
         self, ops: Iterable[cirq.Operation], after_to_before: bool = False
-    ) -> PauliString:
+    ) -> PauliString:  # pragma: no cover
         """Determines how the Pauli string changes when conjugated by Cliffords.
 
         The output and input pauli strings are related by a circuit equivalence.
@@ -1099,9 +1101,6 @@ class PauliString(raw_types.Operation, Generic[TKey]):
                 pauli string, instead of before (and so are moving in the
                 opposite direction).
         """
-        # 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)
 

cirq/ops/pauli_string_phasor.py

@@ -30,7 +30,7 @@ from typing import (
 import sympy
 
 from cirq import protocols, value
-from cirq._compat import proper_repr
+from cirq._compat import deprecated, proper_repr
 from cirq.ops import (
     common_gates,
     dense_pauli_string as dps,
@@ -199,9 +199,21 @@ class PauliStringPhasor(gate_operation.GateOperation):
         syms = tuple(sym(qubit) for qubit in qubits)
         return protocols.CircuitDiagramInfo(wire_symbols=syms, exponent=self.exponent_relative)
 
+    def conjugated_by(self, clifford: 'cirq.OP_TREE') -> 'PauliStringPhasor':
+        r"""Returns the Pauli string conjugated by a clifford operation.
+
+        The PauliStringPhasor $P$ conjugated by the Clifford operation $C$ is
+          $C^\dagger P C$.
+        """
+        new_pauli_string: ps.PauliString = self.pauli_string.conjugated_by(clifford)
+        pp = self.exponent_pos
+        pn = self.exponent_neg
+        return PauliStringPhasor(new_pauli_string, exponent_pos=pp, exponent_neg=pn)
+
+    @deprecated(deadline="v2.0", fix="Use conjuagetd_by() instead.")
     def pass_operations_over(
         self, ops: Iterable[raw_types.Operation], after_to_before: bool = False
-    ) -> PauliStringPhasor:
+    ) -> PauliStringPhasor:  # pragma: no cover
         """Determines how the Pauli phasor changes when conjugated by Cliffords.
 
         The output and input pauli phasors are related by a circuit equivalence.
@@ -228,7 +240,12 @@ class PauliStringPhasor(gate_operation.GateOperation):
                 pauli string, instead of before (and so are moving in the
                 opposite direction).
         """
-        new_pauli_string = self.pauli_string.pass_operations_over(ops, after_to_before)
+        new_pauli_string: ps.PauliString = ps.PauliString()
+        if after_to_before:
+            new_pauli_string = self.pauli_string.after(ops)
+        else:
+            all_ops = list(op_tree.flatten_to_ops(ops))
+            new_pauli_string = self.pauli_string.before(all_ops[::-1])
         pp = self.exponent_pos
         pn = self.exponent_neg
         return PauliStringPhasor(new_pauli_string, exponent_pos=pp, exponent_neg=pn)

cirq/ops/pauli_string_phasor_test.py

@@ -155,7 +155,7 @@ def test_consistent():
     cirq.testing.assert_implements_consistent_protocols(p)
 
 
-def test_pass_operations_over():
+def test_conjugated_by():
     q0, q1 = _make_qubits(2)
     op = cirq.SingleQubitCliffordGate.from_double_map(
         {cirq.Z: (cirq.X, False), cirq.X: (cirq.Z, False)}
@@ -164,10 +164,7 @@ 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]).pauli_string == after.pauli_string
-    assert (
-        after.pass_operations_over([op], after_to_before=True).pauli_string == before.pauli_string
-    )
+    assert before.conjugated_by(op).pauli_string == after.pauli_string
 
 
 def test_extrapolate_effect():

cirq/ops/pauli_string_test.py

@@ -14,7 +14,6 @@
 
 import itertools
 import math
-from typing import List
 
 import numpy as np
 import pytest
@@ -723,118 +722,6 @@ def test_to_z_basis_ops_product_state():
     )
 
 
-def _assert_pass_over(ops: List[cirq.Operation], before: cirq.PauliString, after: cirq.PauliString):
-    assert before.pass_operations_over(ops[::-1]) == after
-    assert after.pass_operations_over(ops, after_to_before=True) == before
-
-
-@pytest.mark.parametrize('shift,sign', itertools.product(range(3), (-1, +1)))
-def test_pass_operations_over_single(shift: int, sign: int):
-    q0, q1 = _make_qubits(2)
-    X, Y, Z = (cirq.Pauli.by_relative_index(pauli, shift) for pauli in (cirq.X, cirq.Y, cirq.Z))
-
-    op0 = cirq.SingleQubitCliffordGate.from_pauli(Y)(q1)
-    ps_before: cirq.PauliString[cirq.Qid] = cirq.PauliString({q0: X}, sign)
-    ps_after = ps_before
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op0 = cirq.SingleQubitCliffordGate.from_pauli(X)(q0)
-    op1 = cirq.SingleQubitCliffordGate.from_pauli(Y)(q1)
-    ps_before = cirq.PauliString({q0: X, q1: Y}, sign)
-    ps_after = ps_before
-    _assert_pass_over([op0, op1], ps_before, ps_after)
-
-    op0 = cirq.SingleQubitCliffordGate.from_double_map({Z: (X, False), X: (Z, False)})(q0)
-    ps_before = cirq.PauliString({q0: X, q1: Y}, sign)
-    ps_after = cirq.PauliString({q0: Z, q1: Y}, sign)
-    _assert_pass_over([op0], ps_before, ps_after)
-
-    op1 = cirq.SingleQubitCliffordGate.from_pauli(X)(q1)
-    ps_before = cirq.PauliString({q0: X, q1: Y}, sign)
-    ps_after = -ps_before
-    _assert_pass_over([op1], ps_before, ps_after)
-
-    ps_after = cirq.PauliString({q0: Z, q1: Y}, -sign)
-    _assert_pass_over([op0, op1], ps_before, ps_after)
-
-    op0 = cirq.SingleQubitCliffordGate.from_pauli(Z, True)(q0)
-    op1 = cirq.SingleQubitCliffordGate.from_pauli(X, True)(q0)
-    ps_before = cirq.PauliString({q0: X}, sign)
-    ps_after = cirq.PauliString({q0: Y}, -sign)
-    _assert_pass_over([op0, op1], ps_before, ps_after)
-
-
-@pytest.mark.parametrize(
-    'shift,t_or_f1, t_or_f2,neg', itertools.product(range(3), *((True, False),) * 3)
-)
-def test_pass_operations_over_double(shift: int, t_or_f1: bool, t_or_f2: bool, neg: bool):
-    sign = -1 if neg else +1
-    q0, q1, q2 = _make_qubits(3)
-    X, Y, Z = (cirq.Pauli.by_relative_index(pauli, shift) for pauli in (cirq.X, cirq.Y, cirq.Z))
-
-    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 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 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)
-
-
-def test_pass_operations_over_cz():
-    q0, q1 = _make_qubits(2)
-    op0 = cirq.CZ(q0, q1)
-    ps_before = cirq.PauliString({q0: cirq.Z, q1: cirq.Y})
-    ps_after = cirq.PauliString({q1: cirq.Y})
-    _assert_pass_over([op0], ps_before, ps_after)
-
-
-def test_pass_operations_over_no_common_qubits():
-    class ExampleGate(cirq.testing.SingleQubitGate):
-
-        def _decompose_(self, qubits):
-            return cirq.X(qubits[0])
-
-    q0, q1 = _make_qubits(2)
-    op0 = ExampleGate()(q1)
-    ps_before = cirq.PauliString({q0: cirq.Z})
-    ps_after = cirq.PauliString({q0: cirq.Z})
-    _assert_pass_over([op0], ps_before, ps_after)
-
-
-def test_pass_unsupported_operations_over():
-    (q0,) = _make_qubits(1)
-    pauli_string = cirq.PauliString({q0: cirq.X})
-    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)])
-
-
 def test_with_qubits():
     old_qubits = cirq.LineQubit.range(9)
     new_qubits = cirq.LineQubit.range(9, 18)
@@ -1637,40 +1524,6 @@ def test_conjugated_by_ordering():
     assert out1 == out2 == cirq.X(a) * cirq.Z(b)
 
 
-def test_pass_operations_over_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)]
-
-    a, b = cirq.LineQubit.range(2)
-    inp = cirq.Z(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)
-
-
-def test_pass_operations_over_ordering_reversed():
-    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 = cirq.LineQubit.range(2)
-    inp = cirq.X(a) * cirq.Z(b)
-    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
-    )
-    assert out1 == out2 == out3 == cirq.Z(b)
-
-
 def test_pretty_print():
     a, b, c = cirq.LineQubit.range(3)
     result = cirq.PauliString({a: 'x', b: 'y', c: 'z'})

cirq/transformers/__init__.py

@@ -119,6 +119,8 @@ from cirq.transformers.transformer_api import (
     transformer as transformer,
 )
 
+from cirq.transformers.tag_transformers import index_tags as index_tags, remove_tags as remove_tags
+
 from cirq.transformers.transformer_primitives import (
     map_moments as map_moments,
     map_operations as map_operations,

cirq/transformers/tag_transformers.py

@@ -0,0 +1,95 @@
+# Copyright 2025 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import itertools
+from typing import Callable, Hashable, Optional, TYPE_CHECKING
+
+from cirq.transformers import transformer_api, transformer_primitives
+
+if TYPE_CHECKING:
+    import cirq
+
+
+@transformer_api.transformer
+def index_tags(
+    circuit: 'cirq.AbstractCircuit',
+    *,
+    context: Optional['cirq.TransformerContext'] = None,
+    target_tags: Optional[set[Hashable]] = None,
+) -> 'cirq.Circuit':
+    """Indexes tags in target_tags as tag_0, tag_1, ... per tag.
+
+    Args:
+        circuit: Input circuit to apply the transformations on. The input circuit is not mutated.
+        context: `cirq.TransformerContext` storing common configurable options for transformers.
+        target_tags: Tags to be indexed.
+
+    Returns:
+        Copy of the transformed input circuit.
+    """
+    if context and context.tags_to_ignore:
+        raise ValueError("index_tags doesn't support tags_to_ignore, use function args instead.")
+    if not target_tags:
+        return circuit.unfreeze(copy=False)
+    tag_iter_by_tags = {tag: itertools.count(start=0, step=1) for tag in target_tags}
+
+    def _map_func(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+        tag_set = set(op.tags)
+        nonlocal tag_iter_by_tags
+        for tag in target_tags.intersection(op.tags):
+            tag_set.remove(tag)
+            tag_set.add(f"{tag}_{next(tag_iter_by_tags[tag])}")
+
+        return op.untagged.with_tags(*tag_set)
+
+    return transformer_primitives.map_operations(
+        circuit, _map_func, deep=context.deep if context else False
+    ).unfreeze(copy=False)
+
+
+@transformer_api.transformer
+def remove_tags(
+    circuit: 'cirq.AbstractCircuit',
+    *,
+    context: Optional['cirq.TransformerContext'] = None,
+    target_tags: Optional[set[Hashable]] = None,
+    remove_if: Callable[[Hashable], bool] = lambda _: False,
+) -> 'cirq.Circuit':
+    """Removes tags from the operations based on the input args.
+
+    Args:
+        circuit: Input circuit to apply the transformations on. The input circuit is not mutated.
+        context: `cirq.TransformerContext` storing common configurable options for transformers.
+        target_tags: Tags to be removed.
+        remove_if: A callable(tag) that returns True if the tag should be removed.
+          Defaults to False.
+
+    Returns:
+        Copy of the transformed input circuit.
+    """
+    if context and context.tags_to_ignore:
+        raise ValueError("remove_tags doesn't support tags_to_ignore, use function args instead.")
+    target_tags = target_tags or set()
+
+    def _map_func(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+        remaing_tags = set()
+        for tag in op.tags:
+            if not remove_if(tag) and tag not in target_tags:
+                remaing_tags.add(tag)
+
+        return op.untagged.with_tags(*remaing_tags)
+
+    return transformer_primitives.map_operations(
+        circuit, _map_func, deep=context.deep if context else False
+    ).unfreeze(copy=False)

cirq/transformers/tag_transformers_test.py

@@ -0,0 +1,101 @@
+# Copyright 2025 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+
+import cirq
+
+
+def check_same_circuit_with_same_tag_sets(circuit1, circuit2):
+    for op1, op2 in zip(circuit1.all_operations(), circuit2.all_operations()):
+        assert set(op1.tags) == set(op2.tags)
+        assert op1.untagged == op2.untagged
+
+
+def test_index_tags():
+    q0, q1 = cirq.LineQubit.range(2)
+    input_circuit = cirq.Circuit(
+        cirq.X(q0).with_tags("tag1", "tag2"),
+        cirq.Y(q1).with_tags("tag1"),
+        cirq.CZ(q0, q1).with_tags("tag2"),
+    )
+    expected_circuit = cirq.Circuit(
+        cirq.X(q0).with_tags("tag1_0", "tag2_0"),
+        cirq.Y(q1).with_tags("tag1_1"),
+        cirq.CZ(q0, q1).with_tags("tag2_1"),
+    )
+    check_same_circuit_with_same_tag_sets(
+        cirq.index_tags(input_circuit, target_tags={"tag1", "tag2"}), expected_circuit
+    )
+
+
+def test_index_tags_empty_target_tags():
+    q0, q1 = cirq.LineQubit.range(2)
+    input_circuit = cirq.Circuit(
+        cirq.X(q0).with_tags("tag1", "tag2"),
+        cirq.Y(q1).with_tags("tag1"),
+        cirq.CZ(q0, q1).with_tags("tag2"),
+    )
+    check_same_circuit_with_same_tag_sets(
+        cirq.index_tags(input_circuit, target_tags={}), input_circuit
+    )
+
+
+def test_remove_tags():
+    q0, q1 = cirq.LineQubit.range(2)
+    input_circuit = cirq.Circuit(
+        cirq.X(q0).with_tags("tag1", "tag2"),
+        cirq.Y(q1).with_tags("tag1"),
+        cirq.CZ(q0, q1).with_tags("tag2"),
+    )
+    expected_circuit = cirq.Circuit(
+        cirq.X(q0).with_tags("tag2"), cirq.Y(q1), cirq.CZ(q0, q1).with_tags("tag2")
+    )
+    check_same_circuit_with_same_tag_sets(
+        cirq.remove_tags(input_circuit, target_tags={"tag1"}), expected_circuit
+    )
+
+
+def test_remove_tags_via_remove_if():
+    q0, q1 = cirq.LineQubit.range(2)
+    input_circuit = cirq.Circuit(
+        cirq.X(q0).with_tags("tag1", "tag2"),
+        cirq.Y(q1).with_tags("not_tag1"),
+        cirq.CZ(q0, q1).with_tags("tag2"),
+    )
+    expected_circuit = cirq.Circuit(cirq.X(q0), cirq.Y(q1).with_tags("not_tag1"), cirq.CZ(q0, q1))
+    check_same_circuit_with_same_tag_sets(
+        cirq.remove_tags(input_circuit, remove_if=lambda tag: tag.startswith("tag")),
+        expected_circuit,
+    )
+
+
+def test_index_tags_with_tags_to_ignore():
+    with pytest.raises(
+        ValueError, match="index_tags doesn't support tags_to_ignore, use function args instead."
+    ):
+        cirq.index_tags(
+            circuit=cirq.Circuit(),
+            target_tags={"tag0"},
+            context=cirq.TransformerContext(tags_to_ignore=["tag0"]),
+        )
+
+
+def test_remove_tags_with_tags_to_ignore():
+    with pytest.raises(
+        ValueError, match="remove_tags doesn't support tags_to_ignore, use function args instead."
+    ):
+        cirq.remove_tags(
+            circuit=cirq.Circuit(), context=cirq.TransformerContext(tags_to_ignore=["tag0"])
+        )

{cirq_core-1.6.0.dev20250507172716.dist-info → cirq_core-1.6.0.dev20250507225534.dist-info}/METADATA

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

@@ -1,11 +1,11 @@
-cirq/__init__.py,sha256=rUfvQDtywCak2mJQoihOSyRjGxQahK-YOv909us0w5M,28132
+cirq/__init__.py,sha256=ecDdbOid5m5VpqO4ZPoXQRuWUanrH3Y7lGzzgNPpiyM,28194
 cirq/_compat.py,sha256=_DknO27XngcjEidNApRsCzLUWDS4QmDk9M12BaqP5Is,29531
 cirq/_compat_test.py,sha256=t51ZXkEuomg1SMI871Ws-5pk68DGBsAf2TGNjVXtZ8I,34755
 cirq/_doc.py,sha256=yDyWUD_2JDS0gShfGRb-rdqRt9-WeL7DhkqX7np0Nko,2879
 cirq/_import.py,sha256=cfocxtT1BJ4HkfZ-VO8YyIhPP-xfqHDkLrzz6eeO5U0,8421
 cirq/_import_test.py,sha256=6K_v0riZJXOXUphHNkGA8MY-JcmGlezFaGmvrNhm3OQ,1015
-cirq/_version.py,sha256=AlgIUe9cSvcXSaC_wG3KpjK_MoYOIokHORQMpjdCAo8,1206
-cirq/_version_test.py,sha256=CNrADm0MI1iCUSMW43mxKZgonXXBw4OENMp_s3jqZmw,147
+cirq/_version.py,sha256=hTB6q5KLlQenUB_P9SCUo9H4op-PatyQxgikmCkf8U0,1206
+cirq/_version_test.py,sha256=Yt9Dr26wo6Uhn7hGIoGN0kOoBnN7KUfd5ymMAIBGxCE,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=-4KqEEYb6aps-seafnFTHTp3SZc0D8mr4O-pCKIajn8,13653
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -88,7 +88,7 @@ cirq/contrib/noise_models/__init__.py,sha256=O3wvaQ6kyNZzwsCnMMZvr2EyS76LpO9xnVZ
 cirq/contrib/noise_models/noise_models.py,sha256=i1hCLuI4c6DLMQzBenK1ghAvfnrGKCYgow7tl8Pjf5Q,7674
 cirq/contrib/noise_models/noise_models_test.py,sha256=nELHWYWbRp6RCurjTSEAumpZPMY2gNN3S4Mhho3pwJ0,10488
 cirq/contrib/paulistring/__init__.py,sha256=1k2_MYLTMPn8AFoJvSgpN-F-6xgmDjKXRhb-FdDsFoQ,1761
-cirq/contrib/paulistring/clifford_optimize.py,sha256=zeap55snqMQZL7GiDHCdQztgsRlVYlEsAFYmPtrEBwo,7849
+cirq/contrib/paulistring/clifford_optimize.py,sha256=bdS4pXjBxcJhFiL_jsVeS4Odcd-D02FtyxLVVsWi4LU,7830
 cirq/contrib/paulistring/clifford_optimize_test.py,sha256=Q8REpwDRNEHVYl3yxfzxN7c5dsQLhZSkk842xaKvFrw,3889
 cirq/contrib/paulistring/clifford_target_gateset.py,sha256=7TyfG3ieJluz8AziQKFCT1EgRKLzWu2aoUGAEcLblGw,6369
 cirq/contrib/paulistring/clifford_target_gateset_test.py,sha256=Q_Zqbfp6yVzLabpKLnhIFCnGBaCgsgiABXCuAixwySQ,8668
@@ -100,9 +100,9 @@ cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation.py,sha
 cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation_test.py,sha256=yPFWcZiVkUcwwpjQQsT135JPmj9p5KOS9urzNqUWAfQ,35501
 cirq/contrib/paulistring/pauli_string_optimize.py,sha256=QhowjgeI0vXg_XvF7FmpUgGgDJP9xCbsYS8_womA4Ho,2903
 cirq/contrib/paulistring/pauli_string_optimize_test.py,sha256=2wSpV7EVwuuK8wI_Pp31V4vCIkq-CEmQz3EjaFWi8fM,2895
-cirq/contrib/paulistring/recombine.py,sha256=zm5AJL80Xl4hgTe9U1YUEgWfcHZys_YcWNpnv02DcL0,4355
+cirq/contrib/paulistring/recombine.py,sha256=Q_0RCTfg5i7WaqoynimpYXkuSuE2BIov8jYcan8V1Gk,4343
 cirq/contrib/paulistring/recombine_test.py,sha256=ClvleI2hVVBOA7sbi3yTth-fErJQYYCw-6ebAvXt-Ns,1915
-cirq/contrib/paulistring/separate.py,sha256=clzMvgTUyEW1l-fghk3EYUsKZNOBicy1l2MiuZaoc7o,3960
+cirq/contrib/paulistring/separate.py,sha256=dtGwqXxEiRCxo21wV8uAlA1E3GKQGxr3FuQWqy-jTdM,3926
 cirq/contrib/paulistring/separate_test.py,sha256=FzR78MSHDhNJxizbXreK6u3BeYhT7xn7W1QyHfEZ34E,1267
 cirq/contrib/qasm_import/__init__.py,sha256=RKX0vGDC2Pe5rH5rM4ClXdvtrAU16ePFImQpiJtJVNo,744
 cirq/contrib/qasm_import/_lexer.py,sha256=RkrbOoT5flW_NEzdxRgv4nbmJ1mWJWlENPf7aPAVM9Y,2929
@@ -339,12 +339,12 @@ cirq/ops/pauli_interaction_gate.py,sha256=hGYmC1i8UCDDJ6e3ML6M8GeW-byq_dLoNv5UvB
 cirq/ops/pauli_interaction_gate_test.py,sha256=adnIIgCvFzO-inNaN77HER-WJ0hg6L63_HfiT60oV3M,4543
 cirq/ops/pauli_measurement_gate.py,sha256=R64b1zbnwecKTkZHXzOcro21OubDu-wibRk5ppwFfLk,7217
 cirq/ops/pauli_measurement_gate_test.py,sha256=acKmYvwSQniIX2FtOCVrIPRPmyUBeV4uNUFmyShJixE,6778
-cirq/ops/pauli_string.py,sha256=c_9fAJQJR17SZYNCi02AhCdJj5L9zkjZJlgUA1cQv7w,66785
-cirq/ops/pauli_string_phasor.py,sha256=OEF2xW5NM0y_4wcL6BLoN_RfBFeQkksh6QcO1qlwyDA,17476
-cirq/ops/pauli_string_phasor_test.py,sha256=PT2PmSeXG8JS45gyUrVpXdTifwpNTCmU0ASUZ9WDk1Q,27865
+cirq/ops/pauli_string.py,sha256=OUqhn_gdf3RkYM3G1amiPaHMU89kOUBCSA3AFaWjGnI,66771
+cirq/ops/pauli_string_phasor.py,sha256=WZTsn6ed5H0M3io7ErMrPjFYP9o5huWN63zuabR6PYw,18280
+cirq/ops/pauli_string_phasor_test.py,sha256=R6YLz66Q1Mh2BblMVmXpdR32iNRy_TK1mPENfbzz3G4,27731
 cirq/ops/pauli_string_raw_types.py,sha256=200Epv_YmR33YVEL8wT198S04GAruyG7I0xVtVk8oqk,2269
 cirq/ops/pauli_string_raw_types_test.py,sha256=SZPluslZPGffPq93F5apESBygWZ2cj7BEX6dQuawRQE,2648
-cirq/ops/pauli_string_test.py,sha256=OcOUSiR-ja1yfEr3GY8Mx3yogmDwr6_yCuXOU2XF3W4,78869
+cirq/ops/pauli_string_test.py,sha256=t4nrqnunT412KzOKac5Wb9NdiZGoR8exWy31GmFXmSk,72831
 cirq/ops/pauli_sum_exponential.py,sha256=o-OsJ6SfsYNnMdSTpAaL1uauTKh9SLL3oLLoh7y4IV0,4868
 cirq/ops/pauli_sum_exponential_test.py,sha256=Vi2-0zDUCS4XtFn9dfmkgh9dH2ncuKYOiQLCZPoLMkg,5369
 cirq/ops/permutation_gate.py,sha256=uLd0qZgT4eDKO22Me9HGSDD7Hnf1Ol3ddkwJ7ZghL3U,4224
@@ -1046,7 +1046,7 @@ cirq/testing/test_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 cirq/testing/test_data/test_module_missing_json_test_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cirq/testing/test_data/test_module_missing_testspec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cirq/testing/test_data/test_module_missing_testspec/json_test_data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cirq/transformers/__init__.py,sha256=QjYovkmQHRi7D6nPHkWrszVBM_1__thvOXG4wcYvX_E,6905
+cirq/transformers/__init__.py,sha256=8k80MycPGQzZdJztV4eDpDAo6qpV7SA7GbG2vFiBAcg,7006
 cirq/transformers/align.py,sha256=XmARu30-wwsWMB-3z0K8WJ7zyErrdsTtgXgMDm4co6A,3355
 cirq/transformers/align_test.py,sha256=AI26PxERbtJDfjKtoz17xVAKn6TSr-9pyImqfr5LJWc,7686
 cirq/transformers/drop_empty_moments.py,sha256=j7zAoEsPs9JQ_zYpQX2yEvfiViDiYejnaOJ9GsXNbx4,1548
@@ -1081,6 +1081,8 @@ cirq/transformers/stratify.py,sha256=jfZEQuKv1YT8RdtcbGNsUNp4cs0WzZoiet-e5zwfLTc
 cirq/transformers/stratify_test.py,sha256=17ic2VAUPEGuPG2o5j98yDxQ2j2J_PN3EsPsfh5xwUk,15220
 cirq/transformers/synchronize_terminal_measurements.py,sha256=uh3u53xLjQLyZvh6KY-oOk_i6j8VveMeOi_zGdi748I,3856
 cirq/transformers/synchronize_terminal_measurements_test.py,sha256=VTiw5S3s_Y31qR7ME8Mzv50LdJ_6M3DOtgwvtziQzPI,7742
+cirq/transformers/tag_transformers.py,sha256=7Y5w6sKjT5Ccevwu3EysSMLZ4mZvW9jM2wcAFDqBOnU,3510
+cirq/transformers/tag_transformers_test.py,sha256=qyA9Z6lVk5lRnml6x63EREMUeyCAnxVfRQeA9KN4a0o,3403
 cirq/transformers/transformer_api.py,sha256=zH4suvb0iLPIJ_znCIpJGag4GSiycdPOk2nbbS14C1w,16961
 cirq/transformers/transformer_api_test.py,sha256=YBkIX-R6vYeQz1Y_sqpzDlvNYszEtfvkegoA8dAVVVc,13286
 cirq/transformers/transformer_primitives.py,sha256=q88fl6KGdJvx5mZqnorZv4oR92JK1k6Jm2JZBbjx4Ms,36642
@@ -1212,8 +1214,8 @@ cirq/work/sampler.py,sha256=b7O3B8bc77KQb8ReLx7qeF8owP1Qwb5_I-RwC6-M_C8,19118
 cirq/work/sampler_test.py,sha256=TBJm3gepuOURwklJTXNdqj0thvdqKUvrZwZqdytJxNY,13313
 cirq/work/zeros_sampler.py,sha256=vHCfqkXmUcPkaDuKHlY-UQ71dUHVroEtm_XW51mZpHs,2390
 cirq/work/zeros_sampler_test.py,sha256=TR3AXYSfg3ETpeaEtrmE-GgZsPtfZkUZ36kyH9JquJk,3313
-cirq_core-1.6.0.dev20250507172716.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.6.0.dev20250507172716.dist-info/METADATA,sha256=j--9sDJdwJeC6dRf1vf3ir19WZl8FZuOt1RzpsJtJvo,4908
-cirq_core-1.6.0.dev20250507172716.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-cirq_core-1.6.0.dev20250507172716.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.6.0.dev20250507172716.dist-info/RECORD,,
+cirq_core-1.6.0.dev20250507225534.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.6.0.dev20250507225534.dist-info/METADATA,sha256=t80B3z06_iMsNyOWwLvSh4xNe_TlVBNQ6tOCihY7rkA,4908
+cirq_core-1.6.0.dev20250507225534.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+cirq_core-1.6.0.dev20250507225534.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.6.0.dev20250507225534.dist-info/RECORD,,