cirq-core 1.1.0.dev20221220224914__py3-none-any.whl → 1.2.0__py3-none-any.whl

cirq/transformers/analytical_decompositions/quantum_shannon_decomposition_test.py

@@ -0,0 +1,112 @@
+# 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
+from cirq.ops import common_gates
+from cirq.transformers.analytical_decompositions.quantum_shannon_decomposition import (
+    _multiplexed_cossin,
+    _nth_gray,
+    _msb_demuxer,
+    _single_qubit_decomposition,
+    quantum_shannon_decomposition,
+)
+
+import pytest
+import numpy as np
+from scipy.stats import unitary_group
+
+
+@pytest.mark.parametrize('n_qubits', list(range(1, 8)))
+def test_random_qsd_n_qubit(n_qubits):
+    U = unitary_group.rvs(2**n_qubits)
+    qubits = [cirq.NamedQubit(f'q{i}') for i in range(n_qubits)]
+    circuit = cirq.Circuit(quantum_shannon_decomposition(qubits, U))
+    # Test return is equal to inital unitary
+    assert cirq.approx_eq(U, circuit.unitary(), atol=1e-9)
+    # Test all operations in gate set
+    gates = (common_gates.Rz, common_gates.Ry, common_gates.ZPowGate, common_gates.CXPowGate)
+    assert all(isinstance(op.gate, gates) for op in circuit.all_operations())
+
+
+def test_qsd_n_qubit_errors():
+    qubits = [cirq.NamedQubit(f'q{i}') for i in range(3)]
+    with pytest.raises(ValueError, match="shaped numpy array"):
+        cirq.Circuit(quantum_shannon_decomposition(qubits, np.eye(9)))
+    with pytest.raises(ValueError, match="is_unitary"):
+        cirq.Circuit(quantum_shannon_decomposition(qubits, np.ones((8, 8))))
+
+
+def test_random_single_qubit_decomposition():
+    U = unitary_group.rvs(2)
+    qubit = cirq.NamedQubit('q0')
+    circuit = cirq.Circuit(_single_qubit_decomposition(qubit, U))
+    # Test return is equal to inital unitary
+    assert cirq.approx_eq(U, circuit.unitary(), atol=1e-9)
+    # Test all operations in gate set
+    gates = (common_gates.Rz, common_gates.Ry, common_gates.ZPowGate, common_gates.CXPowGate)
+    assert all(isinstance(op.gate, gates) for op in circuit.all_operations())
+
+
+def test_msb_demuxer():
+    U1 = unitary_group.rvs(4)
+    U2 = unitary_group.rvs(4)
+    U_full = np.kron([[1, 0], [0, 0]], U1) + np.kron([[0, 0], [0, 1]], U2)
+    qubits = [cirq.NamedQubit(f'q{i}') for i in range(3)]
+    circuit = cirq.Circuit(_msb_demuxer(qubits, U1, U2))
+    # Test return is equal to inital unitary
+    assert cirq.approx_eq(U_full, circuit.unitary(), atol=1e-9)
+    # Test all operations in gate set
+    gates = (common_gates.Rz, common_gates.Ry, common_gates.ZPowGate, common_gates.CXPowGate)
+    assert all(isinstance(op.gate, gates) for op in circuit.all_operations())
+
+
+def test_multiplexed_cossin():
+    angle_1 = np.random.random_sample() * 2 * np.pi
+    angle_2 = np.random.random_sample() * 2 * np.pi
+    c1, s1 = np.cos(angle_1), np.sin(angle_1)
+    c2, s2 = np.cos(angle_2), np.sin(angle_2)
+    multiplexed_ry = [[c1, 0, -s1, 0], [0, c2, 0, -s2], [s1, 0, c1, 0], [0, s2, 0, c2]]
+    multiplexed_ry = np.array(multiplexed_ry)
+    qubits = [cirq.NamedQubit(f'q{i}') for i in range(2)]
+    circuit = cirq.Circuit(_multiplexed_cossin(qubits, [angle_1, angle_2]))
+    # Test return is equal to inital unitary
+    assert cirq.approx_eq(multiplexed_ry, circuit.unitary(), atol=1e-9)
+    # Test all operations in gate set
+    gates = (common_gates.Rz, common_gates.Ry, common_gates.ZPowGate, common_gates.CXPowGate)
+    assert all(isinstance(op.gate, gates) for op in circuit.all_operations())
+
+
+@pytest.mark.parametrize(
+    'n, gray',
+    [
+        (0, 0),
+        (1, 1),
+        (2, 3),
+        (3, 2),
+        (4, 6),
+        (5, 7),
+        (6, 5),
+        (7, 4),
+        (8, 12),
+        (9, 13),
+        (10, 15),
+        (11, 14),
+        (12, 10),
+        (13, 11),
+        (14, 9),
+        (15, 8),
+    ],
+)
+def test_nth_gray(n, gray):
+    assert _nth_gray(n) == gray

cirq/transformers/analytical_decompositions/three_qubit_decomposition_test.py

@@ -211,9 +211,7 @@ def test_middle_multiplexor(angles, num_cnots):
             ]
         )
         == num_cnots
-    ), "expected {} CNOTs got \n {} \n {}".format(
-        num_cnots, circuit_u1u2_mid, circuit_u1u2_mid.unitary()
-    )
+    ), f"expected {num_cnots} CNOTs got \n {circuit_u1u2_mid} \n {circuit_u1u2_mid.unitary()}"
 
 
 @pytest.mark.parametrize("shift_left", [True, False])

cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py

@@ -28,7 +28,7 @@ def decompose_two_qubit_interaction_into_four_fsim_gates(
     interaction: Union['cirq.SupportsUnitary', np.ndarray],
     *,
     fsim_gate: Union['cirq.FSimGate', 'cirq.ISwapPowGate'],
-    qubits: Sequence['cirq.Qid'] = None,
+    qubits: Optional[Sequence['cirq.Qid']] = None,
 ) -> 'cirq.Circuit':
     """Decomposes operations into an FSimGate near theta=pi/2, phi=0.
 

cirq/transformers/expand_composite.py

@@ -33,7 +33,7 @@ def expand_composite(
     """A transformer that expands composite operations via `cirq.decompose`.
 
     For each operation in the circuit, this pass examines if the operation can
-    be decomposed. If it can be, the operation is cleared out and and replaced
+    be decomposed. If it can be, the operation is cleared out and replaced
     with its decomposition using a fixed insertion strategy.
 
     Transformation is applied using `cirq.map_operations_and_unroll`, which preserves the

cirq/transformers/heuristic_decompositions/gate_tabulation_math_utils.py

@@ -164,8 +164,8 @@ def kak_vector_infidelity(
 
     if ignore_equivalent_vectors:
         k_diff = k_vec_a - k_vec_b
-        out = 1 - np.product(np.cos(k_diff), axis=-1) ** 2
-        out -= np.product(np.sin(k_diff), axis=-1) ** 2
+        out = 1 - np.prod(np.cos(k_diff), axis=-1) ** 2
+        out -= np.prod(np.sin(k_diff), axis=-1) ** 2
         return out
 
     # We must take the minimum infidelity over all possible locally equivalent
@@ -181,8 +181,8 @@ def kak_vector_infidelity(
 
     k_diff = k_vec_a - k_vec_b
 
-    out = 1 - np.product(np.cos(k_diff), axis=-1) ** 2
-    out -= np.product(np.sin(k_diff), axis=-1) ** 2  # (...,192)
+    out = 1 - np.prod(np.cos(k_diff), axis=-1) ** 2
+    out -= np.prod(np.sin(k_diff), axis=-1) ** 2  # (...,192)
 
     return out.min(axis=-1)
 

cirq/transformers/measurement_transformers.py

@@ -14,7 +14,7 @@
 
 import itertools
 from collections import defaultdict
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, cast, Dict, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
 
@@ -420,13 +420,13 @@ class _ConfusionChannel(ops.Gate):
         return self._kraus
 
     def _apply_channel_(self, args: 'cirq.ApplyChannelArgs'):
-        configs = []
+        configs: List[transformations._BuildFromSlicesArgs] = []
         for i in range(np.prod(self._shape) ** 2):
-            scale = self._confusion_map.flat[i]
+            scale = cast(complex, self._confusion_map.flat[i])
             if scale == 0:
                 continue
             index: Any = np.unravel_index(i, self._shape * 2)
-            slices = []
+            slices: List[transformations._SliceConfig] = []
             axis_count = len(args.left_axes)
             for j in range(axis_count):
                 s1 = transformations._SliceConfig(

cirq/transformers/merge_single_qubit_gates.py

@@ -127,10 +127,23 @@ def merge_single_qubit_moments_to_phxz(
             return None
         ret_ops = []
         for q in m1.qubits | m2.qubits:
-            mat = protocols.unitary(circuits.Circuit(m.operation_at(q) or [] for m in [m1, m2]))
-            gate = single_qubit_decompositions.single_qubit_matrix_to_phxz(mat, atol)
-            if gate:
-                ret_ops.append(gate(q))
+            op1, op2 = m1.operation_at(q), m2.operation_at(q)
+            if op1 and op2:
+                mat = protocols.unitary(op2) @ protocols.unitary(op1)
+                gate = single_qubit_decompositions.single_qubit_matrix_to_phxz(mat, atol)
+                if gate:
+                    ret_ops.append(gate(q))
+            else:
+                op = op1 or op2
+                assert op is not None
+                if isinstance(op.gate, ops.PhasedXZGate):
+                    ret_ops.append(op)
+                else:
+                    gate = single_qubit_decompositions.single_qubit_matrix_to_phxz(
+                        protocols.unitary(op), atol
+                    )
+                    if gate:
+                        ret_ops.append(gate(q))
         return circuits.Moment(ret_ops)
 
     return transformer_primitives.merge_moments(

cirq/transformers/routing/route_circuit_cqc.py

@@ -129,7 +129,7 @@ class RouteCQC:
             context: transformer context storing common configurable options for transformers.
 
         Returns:
-            The routed circuit, which is equivalent to original circuit upto a final qubit
+            The routed circuit, which is equivalent to original circuit up to a final qubit
                 permutation and where each 2-qubit operation is between adjacent qubits in the
                 `device_graph`.
 
@@ -183,7 +183,7 @@ class RouteCQC:
             context: transformer context storing common configurable options for transformers.
 
         Returns:
-            The routed circuit, which is equivalent to original circuit upto a final qubit
+            The routed circuit, which is equivalent to original circuit up to a final qubit
                 permutation and where each 2-qubit operation is between adjacent qubits in the
                 `device_graph`.
             The initial mapping from logical to physical qubits used as part of the routing

cirq/transformers/stratify.py

@@ -15,10 +15,10 @@
 """Transformer pass to repack circuits avoiding simultaneous operations with different classes."""
 
 import itertools
-from typing import TYPE_CHECKING, Type, Callable, Optional, Union, Iterable, Sequence, List, Tuple
+from typing import TYPE_CHECKING, Type, Callable, Dict, Optional, Union, Iterable, Sequence, List
 
-from cirq import ops, circuits, _import
-from cirq.transformers import transformer_api, transformer_primitives
+from cirq import ops, circuits, protocols, _import
+from cirq.transformers import transformer_api
 
 drop_empty_moments = _import.LazyLoader('drop_empty_moments', globals(), 'cirq.transformers')
 
@@ -61,38 +61,36 @@ def stratified_circuit(
     Returns:
         A copy of the original circuit, but with re-arranged operations.
     """
-
     # Normalize categories into classifier functions.
-    classifiers = [_category_to_classifier(category) for category in categories]
-    # Make the classifiers exhaustive by adding an "everything else" bucket.
-    and_the_rest = lambda op: all(not classifier(op) for classifier in classifiers)
-    classifiers_and_the_rest = [*classifiers, and_the_rest]
+    classifiers = _get_classifiers(circuit, categories)
 
     # Try the algorithm with each permutation of the classifiers.
-    classifiers_permutations = list(itertools.permutations(classifiers_and_the_rest))
+    smallest_depth = protocols.num_qubits(circuit) * len(circuit) + 1
+    shortest_stratified_circuit = circuits.Circuit()
     reversed_circuit = circuit[::-1]
-    solutions = []
-    for c in classifiers_permutations:
-        solutions.append(
-            _stratify_circuit(
-                circuit,
-                classifiers=list(c),
-                context=context or transformer_api.TransformerContext(),
-            )
+    for ordered_classifiers in itertools.permutations(classifiers):
+        solution = _stratify_circuit(
+            circuit,
+            classifiers=ordered_classifiers,
+            context=context or transformer_api.TransformerContext(),
         )
+        if len(solution) < smallest_depth:
+            shortest_stratified_circuit = solution
+            smallest_depth = len(solution)
+
         # Do the same thing, except this time in reverse. This helps for some
         # circuits because it inserts operations at the end instead of at the
         # beginning.
-        solutions.append(
-            _stratify_circuit(
-                reversed_circuit,
-                classifiers=list(c),
-                context=context or transformer_api.TransformerContext(),
-            )[::-1]
-        )
+        solution = _stratify_circuit(
+            reversed_circuit,
+            classifiers=ordered_classifiers,
+            context=context or transformer_api.TransformerContext(),
+        )[::-1]
+        if len(solution) < smallest_depth:
+            shortest_stratified_circuit = solution
+            smallest_depth = len(solution)
 
-    # Return the shortest circuit.
-    return min(solutions, key=lambda c: len(c))
+    return shortest_stratified_circuit
 
 
 def _stratify_circuit(
@@ -116,43 +114,88 @@ def _stratify_circuit(
     Returns:
         The stratified circuit.
     """
-    num_categories = len(classifiers) + 1
-
-    def map_func(m: 'cirq.Moment', _) -> Sequence['cirq.Moment']:
-        stratified_ops: List[List['cirq.Operation']] = [[] for _ in range(num_categories)]
-        for op in m:
-            if set(op.tags) & set(context.tags_to_ignore):
-                stratified_ops[0].append(op)
-                continue
-            for i, classifier in enumerate(classifiers):
-                if classifier(op):
-                    stratified_ops[i + 1].append(op)
-                    break
-        return [circuits.Moment(op_list) for op_list in stratified_ops]
-
-    stratified_circuit = transformer_primitives.map_moments(circuit, map_func).unfreeze(copy=False)
-    assert len(stratified_circuit) == len(circuit) * num_categories
-
-    # Try to move operations to the left to reduce circuit depth, preserving stratification.
-    for curr_idx, moment in enumerate(stratified_circuit):
-        curr_category = curr_idx % num_categories
-        if curr_category == 0:
-            # Moment containing tagged operations to be ignored.
-            continue
-        batch_removals: List[Tuple[int, 'cirq.Operation']] = []
-        batch_inserts: List[Tuple[int, 'cirq.Operation']] = []
+    num_classes = len(classifiers) + 1  # include one "extra" category for ignored operations
+    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] = {}
+
+    # The minimum time index for operations with a tag in context.tags_to_ignore.
+    last_ignored_ops_time_index = 0
+
+    for moment in circuit:
+        # Identify the new time indices that operations should be moved into.
+        ignored_ops = []
+        op_time_indices = {}
         for op in moment:
-            prv_idx = stratified_circuit.earliest_available_moment(op, end_moment_index=curr_idx)
-            prv_category = prv_idx % num_categories
-            should_move_to_next_batch = curr_category < prv_category
-            prv_idx += curr_category - prv_category + num_categories * should_move_to_next_batch
-            assert prv_idx <= curr_idx and prv_idx % num_categories == curr_idx % num_categories
-            if prv_idx < curr_idx:
-                batch_inserts.append((prv_idx, op))
-                batch_removals.append((curr_idx, op))
-        stratified_circuit.batch_remove(batch_removals)
-        stratified_circuit.batch_insert_into(batch_inserts)
-    return drop_empty_moments.drop_empty_moments(stratified_circuit)
+
+            # 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
+            )
+
+            # Identify the "class" of this operation (by index).
+            ignored_op = any(tag in op.tags for tag in context.tags_to_ignore)
+            if not ignored_op:
+                op_class = _get_op_class(op, classifiers)
+            else:
+                op_class = len(classifiers)
+                ignored_ops.append(op)
+                min_time_index_for_op = max(min_time_index_for_op, last_ignored_ops_time_index + 1)
+
+            # Identify the time index to place this operation into.
+            time_index = (min_time_index_for_op // num_classes) * num_classes + op_class
+            if time_index < min_time_index_for_op:
+                time_index += num_classes
+            op_time_indices[op] = time_index
+
+        # Assign ignored operations to the same moment.
+        if ignored_ops:
+            last_ignored_ops_time_index = max(op_time_indices[op] for op in ignored_ops)
+            for op in ignored_ops:
+                op_time_indices[op] = last_ignored_ops_time_index
+
+        # Move the operations into their assigned moments.
+        for op, time_index in op_time_indices.items():
+            if time_index >= len(new_moments):
+                new_moments += [[] for _ in range(num_classes)]
+            new_moments[time_index].append(op)
+
+            # Update qubit, measurment key, and control key moments.
+            for qubit in op.qubits:
+                qubit_time_index[qubit] = time_index
+            for key in protocols.measurement_key_objs(op):
+                measurement_time_index[key] = time_index
+            for key in protocols.control_keys(op):
+                control_time_index[key] = time_index
+
+    return circuits.Circuit(circuits.Moment(moment) for moment in new_moments if moment)
+
+
+def _get_classifiers(
+    circuit: circuits.AbstractCircuit, categories: Iterable[Category]
+) -> List[Classifier]:
+    """Convert a collection of categories into a list of classifiers.
+
+    The returned list of classifiers is:
+    - 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]
+
+    # Figure out which classes are actually used in the circuit.
+    class_is_used = [False for _ in classifiers]
+    for op in circuit.all_operations():
+        class_is_used[_get_op_class(op, classifiers)] = True
+        if all(class_is_used):
+            break
+
+    # Return only the classifiers that are used.
+    return [classifier for classifier, is_used in zip(classifiers, class_is_used) if is_used]
 
 
 # No type for `category` because mypy does not keep the return type when
@@ -177,3 +220,23 @@ def _category_to_classifier(category) -> Classifier:
             f'Type[cirq.Gate], Type[cirq.Operation], '
             f'or Callable[[cirq.Operation], bool].'
         )
+
+
+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 _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
+        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.
+    try:
+        return dummy_classifier_index
+    except NameError:
+        raise ValueError(f"Operation {op} not identified by any classifier")

cirq/transformers/stratify_test.py

@@ -224,17 +224,14 @@ def test_stratify_respects_no_compile_operations():
     )
     expected = cirq.Circuit(
         [
+            cirq.Moment(cirq.Z(cirq.LineQubit(4))),
+            cirq.Moment(cirq.ISWAP(cirq.LineQubit(3), cirq.LineQubit(4))),
             cirq.Moment(
                 cirq.TaggedOperation(cirq.X(cirq.LineQubit(0)), 'nocompile'),
                 cirq.TaggedOperation(cirq.ISWAP(cirq.LineQubit(1), cirq.LineQubit(2)), 'nocompile'),
             ),
-            cirq.Moment(cirq.X(cirq.LineQubit(0))),
-            cirq.Moment(cirq.Z(cirq.LineQubit(4))),
-            cirq.Moment(
-                cirq.ISWAP(cirq.LineQubit(3), cirq.LineQubit(4)),
-                cirq.ISWAP(cirq.LineQubit(0), cirq.LineQubit(1)),
-            ),
-            cirq.Moment(cirq.X(cirq.LineQubit(3))),
+            cirq.Moment(cirq.X(cirq.LineQubit(0)), cirq.X(cirq.LineQubit(3))),
+            cirq.Moment(cirq.ISWAP(cirq.LineQubit(0), cirq.LineQubit(1))),
         ]
     )
     cirq.testing.assert_has_diagram(
@@ -254,15 +251,15 @@ def test_stratify_respects_no_compile_operations():
     cirq.testing.assert_has_diagram(
         expected,
         '''
-0: ───X['nocompile']───────X───────iSwap───────
-                                   │
-1: ───iSwap['nocompile']───────────iSwap───────
-      │
-2: ───iSwap────────────────────────────────────
-
-3: ────────────────────────────────iSwap───X───
-                                   │
-4: ────────────────────────────Z───iSwap───────
+0: ───────────────X['nocompile']───────X───iSwap───
+                                           │
+1: ───────────────iSwap['nocompile']───────iSwap───
+                  │
+2: ───────────────iSwap────────────────────────────
+
+3: ───────iSwap────────────────────────X───────────
+          │
+4: ───Z───iSwap────────────────────────────────────
 ''',
     )
     cirq.testing.assert_same_circuits(
@@ -409,3 +406,10 @@ def test_surface_code_cycle_stratifies_without_growing():
     # https://github.com/quantumlib/Cirq/pull/2772/ for some discussion on
     # this, as well as a more optimal but much more complex and slow solution.
     assert len(stratified) == 9
+
+
+def test_unclassified_ops():
+    op = cirq.X(cirq.q(0))
+    classifiers = []
+    with pytest.raises(ValueError, match='not identified by any classifier'):
+        cirq.transformers.stratify._get_op_class(op, classifiers)

cirq/transformers/transformer_api.py

@@ -109,7 +109,7 @@ class TransformerLogger:
     The `LogLevel`s can be used to control the input processing and output resolution of the logs.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initializes TransformerLogger."""
         self._curr_id: int = 0
         self._logs: List[_LoggerNode] = []

cirq/transformers/transformer_primitives.py

@@ -158,7 +158,8 @@ def map_operations(
 
     return map_moments(
         circuit,
-        lambda m, i: [circuits.Moment(apply_map(op, i) for op in m.operations)],
+        lambda m, i: circuits.Circuit(apply_map(op, i) for op in m.operations).moments
+        or [circuits.Moment()],
         deep=deep,
         tags_to_ignore=tags_to_ignore,
     )
@@ -296,7 +297,7 @@ def merge_operations(
 
     The method iterates on the input circuit moment-by-moment from left to right and attempts
     to repeatedly merge each operation in the latest moment with all the corresponding merge-able
-    operations to it's left.
+    operations to its left.
 
     If op1 and op2 are merged, both op1 and op2 are deleted from the circuit and
     the resulting `merged_op` is inserted at the index corresponding to the larger

cirq/transformers/transformer_primitives_test.py

@@ -414,6 +414,17 @@ def test_map_operations_can_add_qubits_if_flag_false():
     cirq.testing.assert_same_circuits(c_mapped, cirq.Circuit(cirq.CNOT(q[0], q[1])))
 
 
+def test_map_operations_maps_different_ops_from_same_moment_to_shared_qubits():
+    q = cirq.LineQubit.range(3)
+    c = cirq.Circuit(cirq.H.on_each(q[:2]))
+    c_mapped = cirq.map_operations(
+        c, lambda op, _: op.controlled_by(q[2]), raise_if_add_qubits=False
+    )
+    cirq.testing.assert_same_circuits(
+        c_mapped, cirq.Circuit(cirq.H(q[0]).controlled_by(q[2]), cirq.H(q[1]).controlled_by(q[2]))
+    )
+
+
 def test_map_operations_can_drop_operations():
     q = cirq.LineQubit.range(2)
     c = cirq.Circuit(cirq.X(q[0]), cirq.Y(q[1]), cirq.X(q[1]), cirq.Y(q[0]))

cirq/value/abc_alt.py

@@ -11,6 +11,7 @@
 # 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.
+
 """A more flexible abstract base class metaclass ABCMetaImplementAnyOneOf."""
 
 import abc
@@ -91,9 +92,9 @@ class ABCMetaImplementAnyOneOf(abc.ABCMeta):
                 value = getattr(cls, name)
             except AttributeError:
                 raise TypeError(
-                    'A method named \'{}\' was listed as a possible '
+                    f"A method named '{name}' was listed as a possible "
                     'implementation alternative but it does not exist in the '
-                    'definition of {!r}.'.format(name, cls)
+                    f'definition of {cls!r}.'
                 )
             if getattr(value, '__isabstractmethod__', False):
                 return False

cirq/value/abc_alt_test.py

@@ -155,6 +155,7 @@ def test_two_alternatives():
         @alternative(requires='alt2', implementation=_default_impl2)
         def my_method(self, arg, kw=99) -> str:
             """Docstring."""
+            raise NotImplementedError
 
         @abc.abstractmethod
         def alt1(self) -> Optional[str]:

cirq/value/classical_data.py

@@ -14,7 +14,8 @@
 
 import abc
 import enum
-from typing import Dict, List, Mapping, Sequence, Tuple, TYPE_CHECKING, TypeVar
+from typing import Dict, List, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing_extensions import Self
 
 from cirq.value import digits, value_equality_attr
 
@@ -38,10 +39,7 @@ class MeasurementType(enum.IntEnum):
     CHANNEL = 2
 
     def __repr__(self):
-        return f'cirq.{str(self)}'
-
-
-TSelf = TypeVar('TSelf', bound='ClassicalDataStoreReader')
+        return f'cirq.MeasurementType.{self.name}'
 
 
 class ClassicalDataStoreReader(abc.ABC):
@@ -101,7 +99,7 @@ class ClassicalDataStoreReader(abc.ABC):
         """
 
     @abc.abstractmethod
-    def copy(self: TSelf) -> TSelf:
+    def copy(self) -> Self:
         """Creates a copy of the object."""
 
 
@@ -142,10 +140,12 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
     def __init__(
         self,
         *,
-        _records: Dict['cirq.MeasurementKey', List[Tuple[int, ...]]] = None,
-        _measured_qubits: Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]] = None,
-        _channel_records: Dict['cirq.MeasurementKey', List[int]] = None,
-        _measurement_types: Dict['cirq.MeasurementKey', 'cirq.MeasurementType'] = None,
+        _records: Optional[Dict['cirq.MeasurementKey', List[Tuple[int, ...]]]] = None,
+        _measured_qubits: Optional[
+            Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]]
+        ] = None,
+        _channel_records: Optional[Dict['cirq.MeasurementKey', List[int]]] = None,
+        _measurement_types: Optional[Dict['cirq.MeasurementKey', 'cirq.MeasurementType']] = None,
     ):
         """Initializes a `ClassicalDataDictionaryStore` object."""
         if not _measurement_types: