cirq-core 1.2.0.dev20230717225858__py3-none-any.whl → 1.3.0__py3-none-any.whl

cirq/transformers/qubit_management_transformers_test.py

@@ -0,0 +1,250 @@
+# Copyright 2023 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 cirq
+
+
+class GateAllocInDecompose(cirq.Gate):
+    def __init__(self, num_alloc: int = 1):
+        self.num_alloc = num_alloc
+
+    def _num_qubits_(self) -> int:
+        return 1
+
+    def _decompose_with_context_(self, qubits, context):
+        assert context is not None
+        qm = context.qubit_manager
+        for q in qm.qalloc(self.num_alloc):
+            yield cirq.CNOT(qubits[0], q)
+            qm.qfree([q])
+
+    def __str__(self):
+        return 'TestGateAlloc'
+
+
+class GateAllocAndBorrowInDecompose(cirq.Gate):
+    def __init__(self, num_alloc: int = 1):
+        self.num_alloc = num_alloc
+
+    def _num_qubits_(self) -> int:
+        return 1
+
+    def __str__(self) -> str:
+        return 'TestGate'
+
+    def _decompose_with_context_(self, qubits, context):
+        assert context is not None
+        qm = context.qubit_manager
+        qa, qb = qm.qalloc(self.num_alloc), qm.qborrow(self.num_alloc)
+        for q, b in zip(qa, qb):
+            yield cirq.CSWAP(qubits[0], q, b)
+        yield cirq.qft(*qb).controlled_by(qubits[0])
+        for q, b in zip(qa, qb):
+            yield cirq.CSWAP(qubits[0], q, b)
+        qm.qfree(qa + qb)
+
+
+def get_decompose_func(gate_type, qm):
+    def decompose_func(op: cirq.Operation, _):
+        return (
+            cirq.decompose_once(op, context=cirq.DecompositionContext(qm))
+            if isinstance(op.gate, gate_type)
+            else op
+        )
+
+    return decompose_func
+
+
+def test_map_clean_and_borrowable_qubits_greedy_types():
+    qm = cirq.ops.SimpleQubitManager()
+    q = cirq.LineQubit.range(2)
+    g = GateAllocInDecompose(1)
+    circuit = cirq.Circuit(cirq.Moment(g(q[0]), g(q[1])))
+    cirq.testing.assert_has_diagram(
+        circuit,
+        """
+0: ───TestGateAlloc───
+
+1: ───TestGateAlloc───
+    """,
+    )
+    unrolled_circuit = cirq.map_operations_and_unroll(
+        circuit, map_func=get_decompose_func(GateAllocInDecompose, qm), raise_if_add_qubits=False
+    )
+    cirq.testing.assert_has_diagram(
+        unrolled_circuit,
+        """
+          ┌──┐
+_c(0): ────X─────
+           │
+_c(1): ────┼X────
+           ││
+0: ────────@┼────
+            │
+1: ─────────@────
+          └──┘
+""",
+    )
+
+    # Maximize parallelism by maximizing qubit width and minimizing qubit reuse.
+    qubit_manager = cirq.GreedyQubitManager(prefix='ancilla', size=2, maximize_reuse=False)
+    allocated_circuit = cirq.map_clean_and_borrowable_qubits(unrolled_circuit, qm=qubit_manager)
+    cirq.testing.assert_has_diagram(
+        allocated_circuit,
+        """
+              ┌──┐
+0: ────────────@─────
+               │
+1: ────────────┼@────
+               ││
+ancilla_0: ────X┼────
+                │
+ancilla_1: ─────X────
+              └──┘
+    """,
+    )
+
+    # Minimize parallelism by minimizing qubit width and maximizing qubit reuse.
+    qubit_manager = cirq.GreedyQubitManager(prefix='ancilla', size=2, maximize_reuse=True)
+    allocated_circuit = cirq.map_clean_and_borrowable_qubits(unrolled_circuit, qm=qubit_manager)
+    cirq.testing.assert_has_diagram(
+        allocated_circuit,
+        """
+0: ───────────@───────
+              │
+1: ───────────┼───@───
+              │   │
+ancilla_1: ───X───X───
+    """,
+    )
+
+
+def test_map_clean_and_borrowable_qubits_borrows():
+    qm = cirq.ops.SimpleQubitManager()
+    op = GateAllocAndBorrowInDecompose(3).on(cirq.NamedQubit("original"))
+    extra = cirq.LineQubit.range(3)
+    circuit = cirq.Circuit(
+        cirq.H.on_each(*extra),
+        cirq.Moment(op),
+        cirq.decompose_once(op, context=cirq.DecompositionContext(qm)),
+    )
+    cirq.testing.assert_has_diagram(
+        circuit,
+        """
+_b(0): ─────────────────────×───────────qft───×───────────
+                            │           │     │
+_b(1): ─────────────────────┼───×───────#2────┼───×───────
+                            │   │       │     │   │
+_b(2): ─────────────────────┼───┼───×───#3────┼───┼───×───
+                            │   │   │   │     │   │   │
+_c(0): ─────────────────────×───┼───┼───┼─────×───┼───┼───
+                            │   │   │   │     │   │   │
+_c(1): ─────────────────────┼───×───┼───┼─────┼───×───┼───
+                            │   │   │   │     │   │   │
+_c(2): ─────────────────────┼───┼───×───┼─────┼───┼───×───
+                            │   │   │   │     │   │   │
+0: ──────────H──────────────┼───┼───┼───┼─────┼───┼───┼───
+                            │   │   │   │     │   │   │
+1: ──────────H──────────────┼───┼───┼───┼─────┼───┼───┼───
+                            │   │   │   │     │   │   │
+2: ──────────H──────────────┼───┼───┼───┼─────┼───┼───┼───
+                            │   │   │   │     │   │   │
+original: ───────TestGate───@───@───@───@─────@───@───@───
+""",
+    )
+    allocated_circuit = cirq.map_clean_and_borrowable_qubits(circuit)
+    cirq.testing.assert_has_diagram(
+        allocated_circuit,
+        """
+0: ───────────H──────────×───────────qft───×───────────
+                         │           │     │
+1: ───────────H──────────┼───×───────#2────┼───×───────
+                         │   │       │     │   │
+2: ───────────H──────────┼───┼───×───#3────┼───┼───×───
+                         │   │   │   │     │   │   │
+ancilla_0: ──────────────×───┼───┼───┼─────×───┼───┼───
+                         │   │   │   │     │   │   │
+ancilla_1: ──────────────┼───×───┼───┼─────┼───×───┼───
+                         │   │   │   │     │   │   │
+ancilla_2: ──────────────┼───┼───×───┼─────┼───┼───×───
+                         │   │   │   │     │   │   │
+original: ────TestGate───@───@───@───@─────@───@───@───""",
+    )
+    decompose_func = get_decompose_func(GateAllocAndBorrowInDecompose, qm)
+    allocated_and_decomposed_circuit = cirq.map_clean_and_borrowable_qubits(
+        cirq.map_operations_and_unroll(circuit, map_func=decompose_func, raise_if_add_qubits=False)
+    )
+    cirq.testing.assert_has_diagram(
+        allocated_and_decomposed_circuit,
+        """
+0: ───────────H───×───────────qft───×───────────×───────────qft───×───────────
+                  │           │     │           │           │     │
+1: ───────────H───┼───×───────#2────┼───×───────┼───×───────#2────┼───×───────
+                  │   │       │     │   │       │   │       │     │   │
+2: ───────────H───┼───┼───×───#3────┼───┼───×───┼───┼───×───#3────┼───┼───×───
+                  │   │   │   │     │   │   │   │   │   │   │     │   │   │
+ancilla_0: ───────×───┼───┼───┼─────×───┼───┼───×───┼───┼───┼─────×───┼───┼───
+                  │   │   │   │     │   │   │   │   │   │   │     │   │   │
+ancilla_1: ───────┼───×───┼───┼─────┼───×───┼───┼───×───┼───┼─────┼───×───┼───
+                  │   │   │   │     │   │   │   │   │   │   │     │   │   │
+ancilla_2: ───────┼───┼───×───┼─────┼───┼───×───┼───┼───×───┼─────┼───┼───×───
+                  │   │   │   │     │   │   │   │   │   │   │     │   │   │
+original: ────────@───@───@───@─────@───@───@───@───@───@───@─────@───@───@───
+            """,
+    )
+
+    # If TestGate is in the first moment then we end up allocating 4 ancilla
+    # qubits because there are no available qubits to borrow in the first moment.
+    allocated_and_decomposed_circuit = cirq.map_clean_and_borrowable_qubits(
+        cirq.map_operations_and_unroll(
+            cirq.align_left(circuit), map_func=decompose_func, raise_if_add_qubits=False
+        )
+    )
+    cirq.testing.assert_has_diagram(
+        allocated_and_decomposed_circuit,
+        """
+0: ───────────H───×───────#2────────×───────×───────────qft───×───────────
+                  │       │         │       │           │     │
+1: ───────────H───┼───×───#3────────┼───×───┼───×───────#2────┼───×───────
+                  │   │   │         │   │   │   │       │     │   │
+2: ───────────H───┼───┼───┼─────────┼───┼───┼───┼───×───#3────┼───┼───×───
+                  │   │   │         │   │   │   │   │   │     │   │   │
+ancilla_0: ───×───┼───┼───┼─────×───┼───┼───┼───×───┼───┼─────┼───×───┼───
+              │   │   │   │     │   │   │   │   │   │   │     │   │   │
+ancilla_1: ───×───┼───┼───qft───×───┼───┼───×───┼───┼───┼─────×───┼───┼───
+              │   │   │   │     │   │   │   │   │   │   │     │   │   │
+ancilla_2: ───┼───×───┼───┼─────┼───×───┼───┼───┼───×───┼─────┼───┼───×───
+              │   │   │   │     │   │   │   │   │   │   │     │   │   │
+ancilla_3: ───┼───┼───×───┼─────┼───┼───×───┼───┼───┼───┼─────┼───┼───┼───
+              │   │   │   │     │   │   │   │   │   │   │     │   │   │
+original: ────@───@───@───@─────@───@───@───@───@───@───@─────@───@───@───
+""",
+    )
+
+
+def test_map_clean_and_borrowable_qubits_deallocates_only_once():
+    q = [cirq.ops.BorrowableQubit(i) for i in range(2)] + [cirq.q('q')]
+    circuit = cirq.Circuit(cirq.X.on_each(*q), cirq.Y(q[1]), cirq.Z(q[1]))
+    greedy_mm = cirq.GreedyQubitManager(prefix="a", size=2)
+    mapped_circuit = cirq.map_clean_and_borrowable_qubits(circuit, qm=greedy_mm)
+    cirq.testing.assert_has_diagram(
+        mapped_circuit,
+        '''
+a_0: ───X───────────
+
+a_1: ───X───Y───Z───
+
+q: ─────X───────────
+''',
+    )

cirq/transformers/routing/route_circuit_cqc.py

@@ -15,7 +15,7 @@
 """Heuristic qubit routing algorithm based on arxiv:1902.08091."""
 
 from typing import Any, Dict, List, Optional, Set, Sequence, Tuple, TYPE_CHECKING
-from itertools import combinations
+import itertools
 import networkx as nx
 
 from cirq import circuits, ops, protocols
@@ -48,7 +48,9 @@ def _disjoint_nc2_combinations(
     Returns:
         All 2-combinations between qubit pairs that are disjoint.
     """
-    return [pair for pair in combinations(qubit_pairs, 2) if set(pair[0]).isdisjoint(pair[1])]
+    return [
+        pair for pair in itertools.combinations(qubit_pairs, 2) if set(pair[0]).isdisjoint(pair[1])
+    ]
 
 
 @transformer_api.transformer
@@ -245,17 +247,34 @@ class RouteCQC:
         The i'th entry in the nested two-qubit and single-qubit ops correspond to the two-qubit
         gates and single-qubit gates of the i'th timesteps respectively. When constructing the
         output routed circuit, single-qubit operations are inserted before two-qubit operations.
+
+        Raises:
+            ValueError: if circuit has intermediate measurements that act on three or more
+                        qubits with a custom key.
         """
         two_qubit_circuit = circuits.Circuit()
         single_qubit_ops: List[List[cirq.Operation]] = []
-        for moment in circuit:
+
+        for i, moment in enumerate(circuit):
             for op in moment:
                 timestep = two_qubit_circuit.earliest_available_moment(op)
                 single_qubit_ops.extend([] for _ in range(timestep + 1 - len(single_qubit_ops)))
                 two_qubit_circuit.append(
                     circuits.Moment() for _ in range(timestep + 1 - len(two_qubit_circuit))
                 )
-                if protocols.num_qubits(op) == 2 and not protocols.is_measurement(op):
+                if protocols.num_qubits(op) > 2 and protocols.is_measurement(op):
+                    key = op.gate.key  # type: ignore
+                    default_key = ops.measure(op.qubits).gate.key  # type: ignore
+                    if len(circuit.moments) == i + 1:
+                        single_qubit_ops[timestep].append(op)
+                    elif key in ('', default_key):
+                        single_qubit_ops[timestep].extend(ops.measure(qubit) for qubit in op.qubits)
+                    else:
+                        raise ValueError(
+                            'Intermediate measurements on three or more qubits '
+                            'with a custom key are not supported'
+                        )
+                elif protocols.num_qubits(op) == 2:
                     two_qubit_circuit[timestep] = two_qubit_circuit[timestep].with_operation(op)
                 else:
                     single_qubit_ops[timestep].append(op)

cirq/transformers/routing/route_circuit_cqc_test.py

@@ -107,6 +107,48 @@ def test_circuit_with_measurement_gates():
     cirq.testing.assert_same_circuits(routed_circuit, circuit)
 
 
+def test_circuit_with_two_qubit_intermediate_measurement_gate():
+    device = cirq.testing.construct_ring_device(2)
+    device_graph = device.metadata.nx_graph
+    router = cirq.RouteCQC(device_graph)
+    qs = cirq.LineQubit.range(2)
+    hard_coded_mapper = cirq.HardCodedInitialMapper({qs[i]: qs[i] for i in range(2)})
+    circuit = cirq.Circuit([cirq.Moment(cirq.measure(qs)), cirq.Moment(cirq.H.on_each(qs))])
+    routed_circuit = router(
+        circuit, initial_mapper=hard_coded_mapper, context=cirq.TransformerContext(deep=True)
+    )
+    device.validate_circuit(routed_circuit)
+
+
+def test_circuit_with_multi_qubit_intermediate_measurement_gate_and_with_default_key():
+    device = cirq.testing.construct_ring_device(3)
+    device_graph = device.metadata.nx_graph
+    router = cirq.RouteCQC(device_graph)
+    qs = cirq.LineQubit.range(3)
+    hard_coded_mapper = cirq.HardCodedInitialMapper({qs[i]: qs[i] for i in range(3)})
+    circuit = cirq.Circuit([cirq.Moment(cirq.measure(qs)), cirq.Moment(cirq.H.on_each(qs))])
+    routed_circuit = router(
+        circuit, initial_mapper=hard_coded_mapper, context=cirq.TransformerContext(deep=True)
+    )
+    expected = cirq.Circuit([cirq.Moment(cirq.measure_each(qs)), cirq.Moment(cirq.H.on_each(qs))])
+    cirq.testing.assert_same_circuits(routed_circuit, expected)
+
+
+def test_circuit_with_multi_qubit_intermediate_measurement_gate_with_custom_key():
+    device = cirq.testing.construct_ring_device(3)
+    device_graph = device.metadata.nx_graph
+    router = cirq.RouteCQC(device_graph)
+    qs = cirq.LineQubit.range(3)
+    hard_coded_mapper = cirq.HardCodedInitialMapper({qs[i]: qs[i] for i in range(3)})
+    circuit = cirq.Circuit(
+        [cirq.Moment(cirq.measure(qs, key="test")), cirq.Moment(cirq.H.on_each(qs))]
+    )
+    with pytest.raises(ValueError):
+        _ = router(
+            circuit, initial_mapper=hard_coded_mapper, context=cirq.TransformerContext(deep=True)
+        )
+
+
 def test_circuit_with_non_unitary_and_global_phase():
     device = cirq.testing.construct_ring_device(4)
     device_graph = device.metadata.nx_graph

cirq/transformers/stratify.py

@@ -130,7 +130,6 @@ def _stratify_circuit(
         ignored_ops = []
         op_time_indices = {}
         for op in moment:
-
             # Identify the earliest moment that can accommodate this op.
             min_time_index_for_op = circuits.circuit.get_earliest_accommodating_moment_index(
                 op, qubit_time_index, measurement_time_index, control_time_index
@@ -183,9 +182,9 @@ def _get_classifiers(
     - Exhaustive, meaning every operation in the circuit is classified by at least one classifier.
     - Minimal, meaning unused classifiers are forgotten.
     """
-    # Convert all categories into classifiers, and make the list exhaustive by adding a dummy
-    # classifier for otherwise unclassified ops.
-    classifiers = [_category_to_classifier(cat) for cat in categories] + [_dummy_classifier]
+    # Convert all categories into classifiers, and make the list exhaustive by
+    # adding an example classifier for otherwise unclassified ops.
+    classifiers = [_category_to_classifier(cat) for cat in categories] + [_mock_classifier]
 
     # Figure out which classes are actually used in the circuit.
     class_is_used = [False for _ in classifiers]
@@ -222,21 +221,21 @@ def _category_to_classifier(category) -> Classifier:
         )
 
 
-def _dummy_classifier(op: 'cirq.Operation') -> bool:
-    """Dummy classifier, used to "complete" a collection of classifiers and make it exhaustive."""
-    return False  # coverage: ignore
+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:
     """Get the "class" of an operator, by index."""
     for class_index, classifier in enumerate(classifiers):
-        if classifier is _dummy_classifier:
-            dummy_classifier_index = class_index
+        if classifier is _mock_classifier:
+            mock_classifier_index = class_index
         elif classifier(op):
             return class_index
     # If we got this far, the operation did not match any "actual" classifier,
-    # so return the index of the dummy classifer.
+    # so return the index of the mock classifer.
     try:
-        return dummy_classifier_index
+        return mock_classifier_index
     except NameError:
         raise ValueError(f"Operation {op} not identified by any classifier")

cirq/transformers/target_gatesets/compilation_target_gateset_test.py

@@ -19,7 +19,7 @@ from cirq.protocols.decompose_protocol import DecomposeResult
 
 
 def test_compilation_target_gateset():
-    class DummyTargetGateset(cirq.CompilationTargetGateset):
+    class ExampleTargetGateset(cirq.CompilationTargetGateset):
         def __init__(self):
             super().__init__(cirq.AnyUnitaryGateFamily(2))
 
@@ -34,7 +34,7 @@ def test_compilation_target_gateset():
         def preprocess_transformers(self) -> List[cirq.TRANSFORMER]:
             return []
 
-    gateset = DummyTargetGateset()
+    gateset = ExampleTargetGateset()
 
     q = cirq.LineQubit.range(2)
     assert cirq.X(q[0]) not in gateset
@@ -57,7 +57,7 @@ def test_compilation_target_gateset():
     ]
 
 
-class DummyCXTargetGateset(cirq.TwoQubitCompilationTargetGateset):
+class ExampleCXTargetGateset(cirq.TwoQubitCompilationTargetGateset):
     def __init__(self):
         super().__init__(cirq.AnyUnitaryGateFamily(1), cirq.CNOT)
 
@@ -90,7 +90,7 @@ class DummyCXTargetGateset(cirq.TwoQubitCompilationTargetGateset):
 
 def test_two_qubit_compilation_leaves_single_gates_in_gateset():
     q = cirq.LineQubit.range(2)
-    gateset = DummyCXTargetGateset()
+    gateset = ExampleCXTargetGateset()
 
     c = cirq.Circuit(cirq.X(q[0]) ** 0.5)
     cirq.testing.assert_same_circuits(cirq.optimize_for_target_gateset(c, gateset=gateset), c)
@@ -103,7 +103,7 @@ def test_two_qubit_compilation_merges_runs_of_single_qubit_gates():
     q = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.CNOT(*q), cirq.X(q[0]), cirq.Y(q[0]), cirq.CNOT(*q))
     cirq.testing.assert_same_circuits(
-        cirq.optimize_for_target_gateset(c, gateset=DummyCXTargetGateset()),
+        cirq.optimize_for_target_gateset(c, gateset=ExampleCXTargetGateset()),
         cirq.Circuit(
             cirq.CNOT(*q),
             cirq.PhasedXZGate(axis_phase_exponent=-0.5, x_exponent=0, z_exponent=-1).on(q[0]),
@@ -113,7 +113,7 @@ def test_two_qubit_compilation_merges_runs_of_single_qubit_gates():
 
 
 def test_two_qubit_compilation_decompose_operation_not_implemented():
-    gateset = DummyCXTargetGateset()
+    gateset = ExampleCXTargetGateset()
     q = cirq.LineQubit.range(3)
     assert gateset.decompose_to_target_gateset(cirq.measure(q[0]), 1) is NotImplemented
     assert gateset.decompose_to_target_gateset(cirq.measure(*q[:2]), 1) is NotImplemented
@@ -145,7 +145,7 @@ def test_two_qubit_compilation_merge_and_replace_to_target_gateset():
     )
     c_new = cirq.optimize_for_target_gateset(
         c_orig,
-        gateset=DummyCXTargetGateset(),
+        gateset=ExampleCXTargetGateset(),
         context=cirq.TransformerContext(tags_to_ignore=("no_compile",)),
     )
     cirq.testing.assert_has_diagram(
@@ -187,7 +187,7 @@ m: ═════════════════════════
     )
     c_new = cirq.optimize_for_target_gateset(
         c_orig,
-        gateset=DummyCXTargetGateset(),
+        gateset=ExampleCXTargetGateset(),
         context=cirq.TransformerContext(tags_to_ignore=("no_compile",)),
     )
     cirq.testing.assert_has_diagram(
@@ -203,7 +203,7 @@ m: ═════════════════════════
 
 
 def test_two_qubit_compilation_replaces_only_if_2q_gate_count_is_less():
-    class DummyTargetGateset(cirq.TwoQubitCompilationTargetGateset):
+    class ExampleTargetGateset(cirq.TwoQubitCompilationTargetGateset):
         def __init__(self):
             super().__init__(cirq.X, cirq.CNOT)
 
@@ -218,7 +218,7 @@ def test_two_qubit_compilation_replaces_only_if_2q_gate_count_is_less():
     ops = [cirq.Y.on_each(*q), cirq.CNOT(*q), cirq.Z.on_each(*q)]
     c_orig = cirq.Circuit(ops)
     c_expected = cirq.Circuit(cirq.X.on_each(*q), ops[-2:])
-    c_new = cirq.optimize_for_target_gateset(c_orig, gateset=DummyTargetGateset())
+    c_new = cirq.optimize_for_target_gateset(c_orig, gateset=ExampleTargetGateset())
     cirq.testing.assert_same_circuits(c_new, c_expected)
 
 

cirq/transformers/target_gatesets/cz_gateset_test.py

@@ -231,8 +231,7 @@ def test_not_decompose_partial_czs():
 
 
 def test_avoids_decompose_when_matrix_available():
-    class OtherXX(cirq.testing.TwoQubitGate):
-        # coverage: ignore
+    class OtherXX(cirq.testing.TwoQubitGate):  # pragma: no cover
         def _has_unitary_(self) -> bool:
             return True
 
@@ -243,8 +242,7 @@ def test_avoids_decompose_when_matrix_available():
         def _decompose_(self, qubits):
             assert False
 
-    class OtherOtherXX(cirq.testing.TwoQubitGate):
-        # coverage: ignore
+    class OtherOtherXX(cirq.testing.TwoQubitGate):  # pragma: no cover
         def _has_unitary_(self) -> bool:
             return True
 
@@ -262,18 +260,18 @@ def test_avoids_decompose_when_matrix_available():
 
 
 def test_composite_gates_without_matrix():
-    class CompositeDummy(cirq.testing.SingleQubitGate):
+    class CompositeExample(cirq.testing.SingleQubitGate):
         def _decompose_(self, qubits):
             yield cirq.X(qubits[0])
             yield cirq.Y(qubits[0]) ** 0.5
 
-    class CompositeDummy2(cirq.testing.TwoQubitGate):
+    class CompositeExample2(cirq.testing.TwoQubitGate):
         def _decompose_(self, qubits):
             yield cirq.CZ(qubits[0], qubits[1])
-            yield CompositeDummy()(qubits[1])
+            yield CompositeExample()(qubits[1])
 
     q0, q1 = cirq.LineQubit.range(2)
-    circuit = cirq.Circuit(CompositeDummy()(q0), CompositeDummy2()(q0, q1))
+    circuit = cirq.Circuit(CompositeExample()(q0), CompositeExample2()(q0, q1))
     expected = cirq.Circuit(
         cirq.X(q0), cirq.Y(q0) ** 0.5, cirq.CZ(q0, q1), cirq.X(q1), cirq.Y(q1) ** 0.5
     )
@@ -290,11 +288,11 @@ def test_composite_gates_without_matrix():
 
 
 def test_unsupported_gate():
-    class UnsupportedDummy(cirq.testing.TwoQubitGate):
+    class UnsupportedExample(cirq.testing.TwoQubitGate):
         pass
 
     q0, q1 = cirq.LineQubit.range(2)
-    circuit = cirq.Circuit(UnsupportedDummy()(q0, q1))
+    circuit = cirq.Circuit(UnsupportedExample()(q0, q1))
     assert circuit == cirq.optimize_for_target_gateset(circuit, gateset=cirq.CZTargetGateset())
     with pytest.raises(ValueError, match='Unable to convert'):
         _ = cirq.optimize_for_target_gateset(