cirq-core 1.5.0.dev20250409222543__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/transformers/stratify.py

@@ -14,8 +14,10 @@
 
 """Transformer pass to repack circuits avoiding simultaneous operations with different classes."""
 
+from __future__ import annotations
+
 import itertools
-from typing import Callable, Dict, Iterable, List, Optional, Sequence, Type, TYPE_CHECKING, Union
+from typing import Callable, Iterable, Sequence, TYPE_CHECKING, Union
 
 from cirq import _import, circuits, ops, protocols
 from cirq.transformers import transformer_api
@@ -31,17 +33,17 @@ Classifier = Callable[['cirq.Operation'], bool]
 
 # Any of the possible operation categories that we can stratify on.
 Category = Union[
-    'cirq.Gate', 'cirq.Operation', Type['cirq.Gate'], Type['cirq.Operation'], Classifier
+    'cirq.Gate', 'cirq.Operation', type['cirq.Gate'], type['cirq.Operation'], Classifier
 ]
 
 
 @transformer_api.transformer(add_deep_support=True)
 def stratified_circuit(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: cirq.TransformerContext | None = None,
     categories: Iterable[Category] = (),
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Repacks avoiding simultaneous operations with different classes.
 
     This transforms the given circuit to ensure that no operations of different categories are
@@ -96,9 +98,9 @@ def stratified_circuit(
 def _stratify_circuit(
     circuit: circuits.AbstractCircuit,
     *,
-    context: 'cirq.TransformerContext',
+    context: cirq.TransformerContext,
     classifiers: Sequence[Classifier],
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Performs the stratification by iterating through the operations in the
     circuit and using the given classifiers to align them.
 
@@ -115,12 +117,12 @@ def _stratify_circuit(
         The stratified circuit.
     """
     num_classes = len(classifiers) + 1  # include one "extra" category for ignored operations
-    new_moments: List[List['cirq.Operation']] = []
+    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] = {}
+    qubit_time_index: dict[cirq.Qid, int] = {}
+    measurement_time_index: dict[cirq.MeasurementKey, int] = {}
+    control_time_index: dict[cirq.MeasurementKey, int] = {}
 
     # The minimum time index for operations with a tag in context.tags_to_ignore.
     last_ignored_ops_time_index = 0
@@ -162,7 +164,7 @@ def _stratify_circuit(
                 new_moments += [[] for _ in range(num_classes)]
             new_moments[time_index].append(op)
 
-            # Update qubit, measurment key, and control key moments.
+            # Update qubit, measurement key, and control key moments.
             for qubit in op.qubits:
                 qubit_time_index[qubit] = time_index
             for key in protocols.measurement_key_objs(op):
@@ -175,7 +177,7 @@ def _stratify_circuit(
 
 def _get_classifiers(
     circuit: circuits.AbstractCircuit, categories: Iterable[Category]
-) -> List[Classifier]:
+) -> list[Classifier]:
     """Convert a collection of categories into a list of classifiers.
 
     The returned list of classifiers is:
@@ -221,12 +223,12 @@ def _category_to_classifier(category) -> Classifier:
         )
 
 
-def _mock_classifier(op: 'cirq.Operation') -> bool:
+def _mock_classifier(op: cirq.Operation) -> bool:
     """Mock classifier, used to "complete" a collection of classifiers and make it exhaustive."""
     return False  # pragma: no cover
 
 
-def _get_op_class(op: 'cirq.Operation', classifiers: Sequence[Classifier]) -> int:
+def _get_op_class(op: cirq.Operation, classifiers: Sequence[Classifier]) -> int:
     """Get the "class" of an operator, by index."""
     for class_index, classifier in enumerate(classifiers):
         if classifier is _mock_classifier:

cirq/transformers/stratify_test.py

@@ -11,6 +11,9 @@
 # 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.
+
+from __future__ import annotations
+
 import pytest
 
 import cirq

cirq/transformers/symbolize.py

@@ -0,0 +1,103 @@
+# 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.
+
+"""Transformers that symbolize operations."""
+
+from __future__ import annotations
+
+import re
+from typing import Hashable, TYPE_CHECKING
+
+import attrs
+import sympy
+from attrs import validators
+
+from cirq import ops
+from cirq.transformers import transformer_api, transformer_primitives
+
+if TYPE_CHECKING:
+    import cirq
+
+
+@attrs.frozen
+class SymbolizeTag:
+    prefix: str = attrs.field(
+        validator=validators.and_(validators.instance_of(str), validators.min_len(1))
+    )
+
+
+@transformer_api.transformer
+def symbolize_single_qubit_gates_by_indexed_tags(
+    circuit: cirq.AbstractCircuit,
+    *,
+    context: cirq.TransformerContext | None = None,
+    symbolize_tag: SymbolizeTag = SymbolizeTag(prefix="TO-PHXZ"),
+) -> cirq.Circuit:
+    """Symbolizes single qubit operations by indexed tags prefixed by symbolize_tag.prefix.
+
+    Example:
+        >>> from cirq import transformers
+        >>> q0, q1 = cirq.LineQubit.range(2)
+        >>> c = cirq.Circuit(
+        ...         cirq.X(q0).with_tags("phxz_0"),
+        ...         cirq.CZ(q0,q1),
+        ...         cirq.Y(q0).with_tags("phxz_1"),
+        ...         cirq.X(q0))
+        >>> print(c)
+        0: ───X[phxz_0]───@───Y[phxz_1]───X───
+                          │
+        1: ───────────────@───────────────────
+        >>> new_circuit = cirq.symbolize_single_qubit_gates_by_indexed_tags(
+        ...     c, symbolize_tag=transformers.SymbolizeTag(prefix="phxz"))
+        >>> print(new_circuit)
+        0: ───PhXZ(a=a0,x=x0,z=z0)───@───PhXZ(a=a1,x=x1,z=z1)───X───
+                                     │
+        1: ──────────────────────────@──────────────────────────────
+
+    Args:
+        circuit: Input circuit to apply the transformations on. The input circuit is not mutated.
+        context: `cirq.TransformerContext` storing common configurable options for transformers.
+        symbolize_tag: The tag info used to symbolize the phxz gate. Prefix is required.
+
+    Returns:
+        Copy of the transformed input circuit.
+    """
+
+    def _map_func(op: cirq.Operation, _):
+        """Maps an op with tag `{tag_prefix}_i` to a symbolized `PhasedXZGate(xi,zi,ai)`."""
+        tags: set[Hashable] = set(op.tags)
+        tag_id: None | int = None
+        for tag in tags:
+            if re.fullmatch(f"{symbolize_tag.prefix}_\\d+", str(tag)):
+                if tag_id is None:
+                    tag_id = int(str(tag).rsplit("_", maxsplit=-1)[-1])
+                else:
+                    raise ValueError(f"Multiple tags are prefixed with {symbolize_tag.prefix}.")
+        if tag_id is None:
+            return op
+        tags.remove(f"{symbolize_tag.prefix}_{tag_id}")
+        phxz_params = {
+            "x_exponent": sympy.Symbol(f"x{tag_id}"),
+            "z_exponent": sympy.Symbol(f"z{tag_id}"),
+            "axis_phase_exponent": sympy.Symbol(f"a{tag_id}"),
+        }
+
+        return ops.PhasedXZGate(**phxz_params).on(*op.qubits).with_tags(*tags)
+
+    return transformer_primitives.map_operations(
+        circuit.freeze(),
+        _map_func,
+        deep=context.deep if context else False,
+        tags_to_ignore=context.tags_to_ignore if context else [],
+    ).unfreeze(copy=False)

cirq/transformers/symbolize_test.py

@@ -0,0 +1,62 @@
+# 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.
+
+from __future__ import annotations
+
+import pytest
+import sympy
+
+import cirq
+from cirq.transformers.symbolize import SymbolizeTag
+
+
+def test_symbolize_single_qubit_gates_by_indexed_tags_success():
+    q = cirq.NamedQubit("a")
+    input_circuit = cirq.Circuit(
+        cirq.X(q).with_tags("phxz_1"), cirq.Y(q).with_tags("tag1"), cirq.Z(q).with_tags("phxz_0")
+    )
+    output_circuit = cirq.symbolize_single_qubit_gates_by_indexed_tags(
+        input_circuit, symbolize_tag=SymbolizeTag(prefix="phxz")
+    )
+    cirq.testing.assert_same_circuits(
+        output_circuit,
+        cirq.Circuit(
+            cirq.PhasedXZGate(
+                x_exponent=sympy.Symbol("x1"),
+                z_exponent=sympy.Symbol("z1"),
+                axis_phase_exponent=sympy.Symbol("a1"),
+            ).on(q),
+            cirq.Y(q).with_tags("tag1"),
+            cirq.PhasedXZGate(
+                x_exponent=sympy.Symbol("x0"),
+                z_exponent=sympy.Symbol("z0"),
+                axis_phase_exponent=sympy.Symbol("a0"),
+            ).on(q),
+        ),
+    )
+
+
+def test_symbolize_single_qubit_gates_by_indexed_tags_multiple_tags():
+    q = cirq.NamedQubit("a")
+    input_circuit = cirq.Circuit(cirq.X(q).with_tags("TO-PHXZ_0", "TO-PHXZ_2"))
+
+    with pytest.raises(ValueError, match="Multiple tags are prefixed with TO-PHXZ."):
+        cirq.symbolize_single_qubit_gates_by_indexed_tags(input_circuit)
+
+
+def test_symbolize_tag_invalid_prefix():
+    with pytest.raises(ValueError, match="Length of 'prefix' must be >= 1: 0"):
+        SymbolizeTag(prefix="")
+    with pytest.raises(TypeError, match="'prefix' must be <class 'str'>"):
+        SymbolizeTag(prefix=[1])

cirq/transformers/synchronize_terminal_measurements.py

@@ -14,7 +14,9 @@
 
 """Transformer pass to move terminal measurements to the end of circuit."""
 
-from typing import List, Optional, Set, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 from cirq import circuits, protocols
 from cirq.transformers import transformer_api
@@ -23,9 +25,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def find_terminal_measurements(
-    circuit: 'cirq.AbstractCircuit',
-) -> List[Tuple[int, 'cirq.Operation']]:
+def find_terminal_measurements(circuit: cirq.AbstractCircuit) -> list[tuple[int, cirq.Operation]]:
     """Finds all terminal measurements in the given circuit.
 
     A measurement is terminal if there are no other operations acting on the measured qubits
@@ -39,9 +39,9 @@ def find_terminal_measurements(
         (moment_index, measurement_operation).
     """
 
-    open_qubits: Set['cirq.Qid'] = set(circuit.all_qubits())
-    seen_control_keys: Set['cirq.MeasurementKey'] = set()
-    terminal_measurements: Set[Tuple[int, 'cirq.Operation']] = set()
+    open_qubits: set[cirq.Qid] = set(circuit.all_qubits())
+    seen_control_keys: set[cirq.MeasurementKey] = set()
+    terminal_measurements: set[tuple[int, cirq.Operation]] = set()
     for i in range(len(circuit) - 1, -1, -1):
         moment = circuit[i]
         for q in open_qubits:
@@ -62,11 +62,11 @@ def find_terminal_measurements(
 
 @transformer_api.transformer(add_deep_support=True)
 def synchronize_terminal_measurements(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: cirq.TransformerContext | None = None,
     after_other_operations: bool = True,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Move measurements to the end of the circuit.
 
     Move all measurements in a circuit to the final moment, if it can accommodate them (without

cirq/transformers/synchronize_terminal_measurements_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 
 NO_COMPILE_TAG = "no_compile_tag"
@@ -48,14 +50,14 @@ def assert_optimizes(before, after, measure_only_moment=True, with_context=False
     cirq.testing.assert_same_circuits(transformed_circuit, c_expected)
 
 
-def test_no_move():
+def test_no_move() -> None:
     q1 = cirq.NamedQubit('q1')
     before = cirq.Circuit([cirq.Moment([cirq.H(q1)])])
     after = before
     assert_optimizes(before=before, after=after)
 
 
-def test_simple_align():
+def test_simple_align() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     before = cirq.Circuit(
@@ -76,7 +78,7 @@ def test_simple_align():
     assert_optimizes(before=before, after=before, with_context=True)
 
 
-def test_simple_partial_align():
+def test_simple_partial_align() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     before = cirq.Circuit(
@@ -96,7 +98,7 @@ def test_simple_partial_align():
     assert_optimizes(before=before, after=before, with_context=True)
 
 
-def test_slide_forward_one():
+def test_slide_forward_one() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     q3 = cirq.NamedQubit('q3')
@@ -119,7 +121,7 @@ def test_slide_forward_one():
     assert_optimizes(before=before, after=after_no_compile, with_context=True)
 
 
-def test_no_slide_forward_one():
+def test_no_slide_forward_one() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     q3 = cirq.NamedQubit('q3')
@@ -128,7 +130,7 @@ def test_no_slide_forward_one():
     assert_optimizes(before=before, after=after, measure_only_moment=False)
 
 
-def test_blocked_shift_one():
+def test_blocked_shift_one() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     before = cirq.Circuit(
@@ -150,7 +152,7 @@ def test_blocked_shift_one():
     assert_optimizes(before=before, after=before, with_context=True)
 
 
-def test_complex_move():
+def test_complex_move() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     q3 = cirq.NamedQubit('q3')
@@ -182,7 +184,7 @@ def test_complex_move():
     assert_optimizes(before=before, after=before, with_context=True)
 
 
-def test_complex_move_no_slide():
+def test_complex_move_no_slide() -> None:
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
     q3 = cirq.NamedQubit('q3')
@@ -208,13 +210,13 @@ def test_complex_move_no_slide():
     assert_optimizes(before=before, after=before, measure_only_moment=False, with_context=True)
 
 
-def test_multi_qubit():
+def test_multi_qubit() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.H(q1), cirq.measure(q0, q1, key='m'))
     assert_optimizes(before=circuit, after=circuit)
 
 
-def test_classically_controlled_op():
+def test_classically_controlled_op() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.H(q0), cirq.measure(q0, key='m'), cirq.X(q1).with_classical_controls('m')

cirq/transformers/tag_transformers.py

@@ -0,0 +1,97 @@
+# 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.
+
+from __future__ import annotations
+
+import itertools
+from typing import Callable, Hashable, 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: cirq.TransformerContext | None = None,
+    target_tags: set[Hashable] | None = 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: cirq.TransformerContext | None = None,
+    target_tags: set[Hashable] | None = 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:
+        remaining_tags = set()
+        for tag in op.tags:
+            if not remove_if(tag) and tag not in target_tags:
+                remaining_tags.add(tag)
+
+        return op.untagged.with_tags(*remaining_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,103 @@
+# 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.
+
+from __future__ import annotations
+
+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"])
+        )