cirq-core 1.6.0.dev20250410201400__py3-none-any.whl → 1.6.0.dev20250411012134__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 10, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.1.*")'
     )
 
-__version__ = "1.6.0.dev20250410201400"
+__version__ = "1.6.0.dev20250411012134"

cirq/_version_test.py

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

cirq/circuits/circuit_operation.py

@@ -22,7 +22,6 @@ component operations in order, including any nested CircuitOperations.
 from __future__ import annotations
 
 import math
-import warnings
 from functools import cached_property
 from typing import (
     Any,
@@ -49,6 +48,7 @@ from cirq._compat import proper_repr
 if TYPE_CHECKING:
     import cirq
 
+
 INT_CLASSES = (int, np.integer)
 INT_TYPE = Union[int, np.integer]
 IntParam = Union[INT_TYPE, sympy.Expr]
@@ -123,9 +123,8 @@ class CircuitOperation(ops.Operation):
             use_repetition_ids: When True, any measurement key in the subcircuit
                 will have its path prepended with the repetition id for each
                 repetition. When False, this will not happen and the measurement
-                key will be repeated. The default is True, but it will be changed
-                to False in the next release.  Please pass an explicit argument
-                ``use_repetition_ids=True`` to preserve the current behavior.
+                key will be repeated. When None, default to False unless the caller
+                passes `repetition_ids` explicitly.
             repeat_until: A condition that will be tested after each iteration of
                 the subcircuit. The subcircuit will repeat until condition returns
                 True, but will always run at least once, and the measurement key
@@ -162,18 +161,8 @@ class CircuitOperation(ops.Operation):
         self._repetitions = repetitions
         self._repetition_ids = None if repetition_ids is None else list(repetition_ids)
         if use_repetition_ids is None:
-            if repetition_ids is None:
-                msg = (
-                    "In cirq 1.6 the default value of `use_repetition_ids` will change to\n"
-                    "`use_repetition_ids=False`. To make this warning go away, please pass\n"
-                    "explicit `use_repetition_ids`, e.g., to preserve current behavior, use\n"
-                    "\n"
-                    "  CircuitOperations(..., use_repetition_ids=True)"
-                )
-                warnings.warn(msg, FutureWarning)
-            self._use_repetition_ids = True
-        else:
-            self._use_repetition_ids = use_repetition_ids
+            use_repetition_ids = repetition_ids is not None
+        self._use_repetition_ids = use_repetition_ids
         if isinstance(self._repetitions, float):
             if math.isclose(self._repetitions, round(self._repetitions)):
                 self._repetitions = round(self._repetitions)
@@ -281,7 +270,9 @@ class CircuitOperation(ops.Operation):
             'repetition_ids': self.repetition_ids,
             'parent_path': self.parent_path,
             'extern_keys': self._extern_keys,
-            'use_repetition_ids': self.use_repetition_ids,
+            'use_repetition_ids': (
+                True if changes.get('repetition_ids') is not None else self.use_repetition_ids
+            ),
             'repeat_until': self.repeat_until,
             **changes,
         }
@@ -485,11 +476,9 @@ class CircuitOperation(ops.Operation):
             args += f'param_resolver={proper_repr(self.param_resolver)},\n'
         if self.parent_path:
             args += f'parent_path={proper_repr(self.parent_path)},\n'
-        if self.repetition_ids != self._default_repetition_ids():
+        if self.use_repetition_ids:
             # Default repetition_ids need not be specified.
             args += f'repetition_ids={proper_repr(self.repetition_ids)},\n'
-        if not self.use_repetition_ids:
-            args += 'use_repetition_ids=False,\n'
         if self.repeat_until:
             args += f'repeat_until={self.repeat_until!r},\n'
         indented_args = args.replace('\n', '\n    ')
@@ -514,14 +503,15 @@ class CircuitOperation(ops.Operation):
             args.append(f'params={self.param_resolver.param_dict}')
         if self.parent_path:
             args.append(f'parent_path={self.parent_path}')
-        if self.repetition_ids != self._default_repetition_ids():
-            # Default repetition_ids need not be specified.
-            args.append(f'repetition_ids={self.repetition_ids}')
+        if self.use_repetition_ids:
+            if self.repetition_ids != self._default_repetition_ids():
+                args.append(f'repetition_ids={self.repetition_ids}')
+            else:
+                # Default repetition_ids need not be specified.
+                args.append(f'loops={self.repetitions}, use_repetition_ids=True')
         elif self.repetitions != 1:
-            # Only add loops if we haven't added repetition_ids.
+            # Add loops if not using repetition_ids.
             args.append(f'loops={self.repetitions}')
-        if not self.use_repetition_ids:
-            args.append('no_rep_ids')
         if self.repeat_until:
             args.append(f'until={self.repeat_until}')
         if not args:
@@ -566,10 +556,9 @@ class CircuitOperation(ops.Operation):
             'measurement_key_map': self.measurement_key_map,
             'param_resolver': self.param_resolver,
             'repetition_ids': self.repetition_ids,
+            'use_repetition_ids': self.use_repetition_ids,
             'parent_path': self.parent_path,
         }
-        if not self.use_repetition_ids:
-            resp['use_repetition_ids'] = False
         if self.repeat_until:
             resp['repeat_until'] = self.repeat_until
         return resp
@@ -603,7 +592,10 @@ class CircuitOperation(ops.Operation):
     # Methods for constructing a similar object with one field modified.
 
     def repeat(
-        self, repetitions: Optional[IntParam] = None, repetition_ids: Optional[Sequence[str]] = None
+        self,
+        repetitions: Optional[IntParam] = None,
+        repetition_ids: Optional[Sequence[str]] = None,
+        use_repetition_ids: Optional[bool] = None,
     ) -> CircuitOperation:
         """Returns a copy of this operation repeated 'repetitions' times.
          Each repetition instance will be identified by a single repetition_id.
@@ -614,6 +606,10 @@ class CircuitOperation(ops.Operation):
                 defaults to the length of `repetition_ids`.
             repetition_ids: List of IDs, one for each repetition. If unset,
                 defaults to `default_repetition_ids(repetitions)`.
+            use_repetition_ids: If given, this specifies the value for `use_repetition_ids`
+                of the resulting circuit operation. If not given, we enable ids if
+                `repetition_ids` is not None, and otherwise fall back to
+                `self.use_repetition_ids`.
 
         Returns:
             A copy of this operation repeated `repetitions` times with the
@@ -628,6 +624,9 @@ class CircuitOperation(ops.Operation):
             ValueError: Unexpected length of `repetition_ids`.
             ValueError: Both `repetitions` and `repetition_ids` are None.
         """
+        if use_repetition_ids is None:
+            use_repetition_ids = True if repetition_ids is not None else self.use_repetition_ids
+
         if repetitions is None:
             if repetition_ids is None:
                 raise ValueError('At least one of repetitions and repetition_ids must be set')
@@ -641,7 +640,7 @@ class CircuitOperation(ops.Operation):
             expected_repetition_id_length: int = np.abs(repetitions)
 
             if repetition_ids is None:
-                if self.use_repetition_ids:
+                if use_repetition_ids:
                     repetition_ids = default_repetition_ids(expected_repetition_id_length)
             elif len(repetition_ids) != expected_repetition_id_length:
                 raise ValueError(
@@ -654,7 +653,11 @@ class CircuitOperation(ops.Operation):
 
         # The eventual number of repetitions of the returned CircuitOperation.
         final_repetitions = protocols.mul(self.repetitions, repetitions)
-        return self.replace(repetitions=final_repetitions, repetition_ids=repetition_ids)
+        return self.replace(
+            repetitions=final_repetitions,
+            repetition_ids=repetition_ids,
+            use_repetition_ids=use_repetition_ids,
+        )
 
     def __pow__(self, power: IntParam) -> cirq.CircuitOperation:
         return self.repeat(power)

cirq/circuits/circuit_operation_test.py

@@ -294,15 +294,15 @@ def test_repeat(add_measurements: bool, use_default_ids_for_initial_rep: bool) -
     op_with_reps: Optional[cirq.CircuitOperation] = None
     rep_ids = []
     if use_default_ids_for_initial_rep:
-        op_with_reps = op_base.repeat(initial_repetitions)
         rep_ids = ['0', '1', '2']
-        assert op_base**initial_repetitions == op_with_reps
+        op_with_reps = op_base.repeat(initial_repetitions, use_repetition_ids=True)
     else:
         rep_ids = ['a', 'b', 'c']
         op_with_reps = op_base.repeat(initial_repetitions, rep_ids)
-        assert op_base**initial_repetitions != op_with_reps
-        assert (op_base**initial_repetitions).replace(repetition_ids=rep_ids) == op_with_reps
+    assert op_base**initial_repetitions != op_with_reps
+    assert (op_base**initial_repetitions).replace(repetition_ids=rep_ids) == op_with_reps
     assert op_with_reps.repetitions == initial_repetitions
+    assert op_with_reps.use_repetition_ids
     assert op_with_reps.repetition_ids == rep_ids
     assert op_with_reps.repeat(1) is op_with_reps
 
@@ -332,8 +332,6 @@ def test_repeat(add_measurements: bool, use_default_ids_for_initial_rep: bool) -
     assert op_base.repeat(2.99999999999).repetitions == 3
 
 
-# TODO: #7232 - enable and fix immediately after the 1.5.0 release
-@pytest.mark.xfail(reason='broken by rollback of use_repetition_ids for #7232')
 def test_replace_repetition_ids() -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.H(a), cirq.CX(a, b), cirq.M(b, key='mb'), cirq.M(a, key='ma'))
@@ -460,6 +458,7 @@ def test_parameterized_repeat_side_effects():
     op = cirq.CircuitOperation(
         cirq.FrozenCircuit(cirq.X(q).with_classical_controls('c'), cirq.measure(q, key='m')),
         repetitions=sympy.Symbol('a'),
+        use_repetition_ids=True,
     )
 
     # Control keys can be calculated because they only "lift" if there's a matching
@@ -713,7 +712,6 @@ cirq.CircuitOperation(
             ),
         ),
     ]),
-    use_repetition_ids=False,
 )"""
     )
     op7 = cirq.CircuitOperation(
@@ -730,7 +728,6 @@ cirq.CircuitOperation(
             cirq.measure(cirq.LineQubit(0), key=cirq.MeasurementKey(name='a')),
         ),
     ]),
-    use_repetition_ids=False,
     repeat_until=cirq.KeyCondition(cirq.MeasurementKey(name='a')),
 )"""
     )
@@ -761,6 +758,7 @@ def test_json_dict():
         'param_resolver': op.param_resolver,
         'parent_path': op.parent_path,
         'repetition_ids': None,
+        'use_repetition_ids': False,
     }
 
 
@@ -867,6 +865,26 @@ def test_decompose_loops_with_measurements():
     circuit = cirq.FrozenCircuit(cirq.H(a), cirq.CX(a, b), cirq.measure(a, b, key='m'))
     base_op = cirq.CircuitOperation(circuit)
 
+    op = base_op.with_qubits(b, a).repeat(3)
+    expected_circuit = cirq.Circuit(
+        cirq.H(b),
+        cirq.CX(b, a),
+        cirq.measure(b, a, key=cirq.MeasurementKey.parse_serialized('m')),
+        cirq.H(b),
+        cirq.CX(b, a),
+        cirq.measure(b, a, key=cirq.MeasurementKey.parse_serialized('m')),
+        cirq.H(b),
+        cirq.CX(b, a),
+        cirq.measure(b, a, key=cirq.MeasurementKey.parse_serialized('m')),
+    )
+    assert cirq.Circuit(cirq.decompose_once(op)) == expected_circuit
+
+
+def test_decompose_loops_with_measurements_use_rep_ids():
+    a, b = cirq.LineQubit.range(2)
+    circuit = cirq.FrozenCircuit(cirq.H(a), cirq.CX(a, b), cirq.measure(a, b, key='m'))
+    base_op = cirq.CircuitOperation(circuit, use_repetition_ids=True)
+
     op = base_op.with_qubits(b, a).repeat(3)
     expected_circuit = cirq.Circuit(
         cirq.H(b),
@@ -1023,7 +1041,9 @@ def test_keys_under_parent_path():
     op3 = cirq.with_key_path_prefix(op2, ('C',))
     assert cirq.measurement_key_names(op3) == {'C:B:A'}
     op4 = op3.repeat(2)
-    assert cirq.measurement_key_names(op4) == {'C:B:0:A', 'C:B:1:A'}
+    assert cirq.measurement_key_names(op4) == {'C:B:A'}
+    op4_rep = op3.repeat(2).replace(use_repetition_ids=True)
+    assert cirq.measurement_key_names(op4_rep) == {'C:B:0:A', 'C:B:1:A'}
 
 
 def test_mapped_circuit_preserves_moments():
@@ -1101,12 +1121,8 @@ def test_mapped_circuit_allows_repeated_keys():
 def test_simulate_no_repetition_ids_both_levels(sim):
     q = cirq.LineQubit(0)
     inner = cirq.Circuit(cirq.measure(q, key='a'))
-    middle = cirq.Circuit(
-        cirq.CircuitOperation(inner.freeze(), repetitions=2, use_repetition_ids=False)
-    )
-    outer_subcircuit = cirq.CircuitOperation(
-        middle.freeze(), repetitions=2, use_repetition_ids=False
-    )
+    middle = cirq.Circuit(cirq.CircuitOperation(inner.freeze(), repetitions=2))
+    outer_subcircuit = cirq.CircuitOperation(middle.freeze(), repetitions=2)
     circuit = cirq.Circuit(outer_subcircuit)
     result = sim.run(circuit)
     assert result.records['a'].shape == (1, 4, 1)
@@ -1116,10 +1132,10 @@ def test_simulate_no_repetition_ids_both_levels(sim):
 def test_simulate_no_repetition_ids_outer(sim):
     q = cirq.LineQubit(0)
     inner = cirq.Circuit(cirq.measure(q, key='a'))
-    middle = cirq.Circuit(cirq.CircuitOperation(inner.freeze(), repetitions=2))
-    outer_subcircuit = cirq.CircuitOperation(
-        middle.freeze(), repetitions=2, use_repetition_ids=False
+    middle = cirq.Circuit(
+        cirq.CircuitOperation(inner.freeze(), repetitions=2, use_repetition_ids=True)
     )
+    outer_subcircuit = cirq.CircuitOperation(middle.freeze(), repetitions=2)
     circuit = cirq.Circuit(outer_subcircuit)
     result = sim.run(circuit)
     assert result.records['0:a'].shape == (1, 2, 1)
@@ -1130,10 +1146,10 @@ def test_simulate_no_repetition_ids_outer(sim):
 def test_simulate_no_repetition_ids_inner(sim):
     q = cirq.LineQubit(0)
     inner = cirq.Circuit(cirq.measure(q, key='a'))
-    middle = cirq.Circuit(
-        cirq.CircuitOperation(inner.freeze(), repetitions=2, use_repetition_ids=False)
+    middle = cirq.Circuit(cirq.CircuitOperation(inner.freeze(), repetitions=2))
+    outer_subcircuit = cirq.CircuitOperation(
+        middle.freeze(), repetitions=2, use_repetition_ids=True
     )
-    outer_subcircuit = cirq.CircuitOperation(middle.freeze(), repetitions=2)
     circuit = cirq.Circuit(outer_subcircuit)
     result = sim.run(circuit)
     assert result.records['0:a'].shape == (1, 2, 1)
@@ -1148,7 +1164,6 @@ def test_repeat_until(sim):
         cirq.X(q),
         cirq.CircuitOperation(
             cirq.FrozenCircuit(cirq.X(q), cirq.measure(q, key=key)),
-            use_repetition_ids=False,
             repeat_until=cirq.KeyCondition(key),
         ),
     )
@@ -1163,7 +1178,6 @@ def test_repeat_until_sympy(sim):
     q1, q2 = cirq.LineQubit.range(2)
     circuitop = cirq.CircuitOperation(
         cirq.FrozenCircuit(cirq.X(q2), cirq.measure(q2, key='b')),
-        use_repetition_ids=False,
         repeat_until=cirq.SympyCondition(sympy.Eq(sympy.Symbol('a'), sympy.Symbol('b'))),
     )
     c = cirq.Circuit(cirq.measure(q1, key='a'), circuitop)
@@ -1183,7 +1197,6 @@ def test_post_selection(sim):
     c = cirq.Circuit(
         cirq.CircuitOperation(
             cirq.FrozenCircuit(cirq.X(q) ** 0.2, cirq.measure(q, key=key)),
-            use_repetition_ids=False,
             repeat_until=cirq.KeyCondition(key),
         )
     )
@@ -1199,14 +1212,13 @@ def test_repeat_until_diagram():
     c = cirq.Circuit(
         cirq.CircuitOperation(
             cirq.FrozenCircuit(cirq.X(q) ** 0.2, cirq.measure(q, key=key)),
-            use_repetition_ids=False,
             repeat_until=cirq.KeyCondition(key),
         )
     )
     cirq.testing.assert_has_diagram(
         c,
         """
-0: ───[ 0: ───X^0.2───M('m')─── ](no_rep_ids, until=m)───
+0: ───[ 0: ───X^0.2───M('m')─── ](until=m)───
 """,
         use_unicode_characters=True,
     )
@@ -1223,7 +1235,6 @@ def test_repeat_until_error():
     with pytest.raises(ValueError, match='Infinite loop'):
         cirq.CircuitOperation(
             cirq.FrozenCircuit(cirq.measure(q, key='m')),
-            use_repetition_ids=False,
             repeat_until=cirq.KeyCondition(cirq.MeasurementKey('a')),
         )
 
@@ -1233,8 +1244,6 @@ def test_repeat_until_protocols():
     op = cirq.CircuitOperation(
         cirq.FrozenCircuit(cirq.H(q) ** sympy.Symbol('p'), cirq.measure(q, key='a')),
         repeat_until=cirq.SympyCondition(sympy.Eq(sympy.Symbol('a'), 0)),
-        # TODO: #7232 - remove immediately after the 1.5.0 release
-        use_repetition_ids=False,
     )
     scoped = cirq.with_rescoped_keys(op, ('0',))
     # Ensure the _repeat_until has been mapped, the measurement has been mapped to the same key,
@@ -1267,8 +1276,6 @@ def test_inner_repeat_until_simulate():
     inner_loop = cirq.CircuitOperation(
         cirq.FrozenCircuit(cirq.H(q), cirq.measure(q, key="inner_loop")),
         repeat_until=cirq.SympyCondition(sympy.Eq(sympy.Symbol("inner_loop"), 0)),
-        # TODO: #7232 - remove immediately after the 1.5.0 release
-        use_repetition_ids=False,
     )
     outer_loop = cirq.Circuit(inner_loop, cirq.X(q), cirq.measure(q, key="outer_loop"))
     circuit = cirq.Circuit(

cirq/ops/classically_controlled_operation_test.py

@@ -358,7 +358,9 @@ def test_subcircuit_key_unset(sim):
         cirq.measure(q1, key='b'),
     )
     circuit = cirq.Circuit(
-        cirq.CircuitOperation(inner.freeze(), repetitions=2, measurement_key_map={'c': 'a'})
+        cirq.CircuitOperation(
+            inner.freeze(), repetitions=2, use_repetition_ids=True, measurement_key_map={'c': 'a'}
+        )
     )
     result = sim.run(circuit)
     assert result.measurements['0:a'] == 0
@@ -377,7 +379,9 @@ def test_subcircuit_key_set(sim):
         cirq.measure(q1, key='b'),
     )
     circuit = cirq.Circuit(
-        cirq.CircuitOperation(inner.freeze(), repetitions=4, measurement_key_map={'c': 'a'})
+        cirq.CircuitOperation(
+            inner.freeze(), repetitions=4, use_repetition_ids=True, measurement_key_map={'c': 'a'}
+        )
     )
     result = sim.run(circuit)
     assert result.measurements['0:a'] == 1
@@ -486,8 +490,12 @@ def test_str():
 def test_scope_local():
     q = cirq.LineQubit(0)
     inner = cirq.Circuit(cirq.measure(q, key='a'), cirq.X(q).with_classical_controls('a'))
-    middle = cirq.Circuit(cirq.CircuitOperation(inner.freeze(), repetitions=2))
-    outer_subcircuit = cirq.CircuitOperation(middle.freeze(), repetitions=2)
+    middle = cirq.Circuit(
+        cirq.CircuitOperation(inner.freeze(), repetitions=2, use_repetition_ids=True)
+    )
+    outer_subcircuit = cirq.CircuitOperation(
+        middle.freeze(), repetitions=2, use_repetition_ids=True
+    )
     circuit = outer_subcircuit.mapped_circuit(deep=True)
     internal_control_keys = [
         str(condition) for op in circuit.all_operations() for condition in cirq.control_keys(op)
@@ -495,15 +503,17 @@ def test_scope_local():
     assert internal_control_keys == ['0:0:a', '0:1:a', '1:0:a', '1:1:a']
     assert not cirq.control_keys(outer_subcircuit)
     assert not cirq.control_keys(circuit)
+    # pylint: disable=line-too-long
     cirq.testing.assert_has_diagram(
         cirq.Circuit(outer_subcircuit),
         """
-      [       [ 0: ───M───X─── ]             ]
-0: ───[ 0: ───[       ║   ║    ]──────────── ]────────────
-      [       [ a: ═══@═══^═══ ](loops=2)    ](loops=2)
+      [       [ 0: ───M───X─── ]                                      ]
+0: ───[ 0: ───[       ║   ║    ]───────────────────────────────────── ]─────────────────────────────────────
+      [       [ a: ═══@═══^═══ ](loops=2, use_repetition_ids=True)    ](loops=2, use_repetition_ids=True)
 """,
         use_unicode_characters=True,
     )
+    # pylint: enable=line-too-long
     cirq.testing.assert_has_diagram(
         circuit,
         """
@@ -541,9 +551,9 @@ def test_scope_flatten_both():
     cirq.testing.assert_has_diagram(
         cirq.Circuit(outer_subcircuit),
         """
-      [       [ 0: ───M───X─── ]                         ]
-0: ───[ 0: ───[       ║   ║    ]──────────────────────── ]────────────────────────
-      [       [ a: ═══@═══^═══ ](loops=2, no_rep_ids)    ](loops=2, no_rep_ids)
+      [       [ 0: ───M───X─── ]             ]
+0: ───[ 0: ───[       ║   ║    ]──────────── ]────────────
+      [       [ a: ═══@═══^═══ ](loops=2)    ](loops=2)
 """,
         use_unicode_characters=True,
     )
@@ -561,10 +571,10 @@ a: ═══@═══^═══@═══^═══@═══^═══@══
 def test_scope_flatten_inner():
     q = cirq.LineQubit(0)
     inner = cirq.Circuit(cirq.measure(q, key='a'), cirq.X(q).with_classical_controls('a'))
-    middle = cirq.Circuit(
-        cirq.CircuitOperation(inner.freeze(), repetitions=2, use_repetition_ids=False)
+    middle = cirq.Circuit(cirq.CircuitOperation(inner.freeze(), repetitions=2))
+    outer_subcircuit = cirq.CircuitOperation(
+        middle.freeze(), repetitions=2, use_repetition_ids=True
     )
-    outer_subcircuit = cirq.CircuitOperation(middle.freeze(), repetitions=2)
     circuit = outer_subcircuit.mapped_circuit(deep=True)
     internal_control_keys = [
         str(condition) for op in circuit.all_operations() for condition in cirq.control_keys(op)
@@ -575,9 +585,9 @@ def test_scope_flatten_inner():
     cirq.testing.assert_has_diagram(
         cirq.Circuit(outer_subcircuit),
         """
-      [       [ 0: ───M───X─── ]                         ]
-0: ───[ 0: ───[       ║   ║    ]──────────────────────── ]────────────
-      [       [ a: ═══@═══^═══ ](loops=2, no_rep_ids)    ](loops=2)
+      [       [ 0: ───M───X─── ]             ]
+0: ───[ 0: ───[       ║   ║    ]──────────── ]─────────────────────────────────────
+      [       [ a: ═══@═══^═══ ](loops=2)    ](loops=2, use_repetition_ids=True)
 """,
         use_unicode_characters=True,
     )
@@ -597,10 +607,10 @@ def test_scope_flatten_inner():
 def test_scope_flatten_outer():
     q = cirq.LineQubit(0)
     inner = cirq.Circuit(cirq.measure(q, key='a'), cirq.X(q).with_classical_controls('a'))
-    middle = cirq.Circuit(cirq.CircuitOperation(inner.freeze(), repetitions=2))
-    outer_subcircuit = cirq.CircuitOperation(
-        middle.freeze(), repetitions=2, use_repetition_ids=False
+    middle = cirq.Circuit(
+        cirq.CircuitOperation(inner.freeze(), repetitions=2, use_repetition_ids=True)
     )
+    outer_subcircuit = cirq.CircuitOperation(middle.freeze(), repetitions=2)
     circuit = outer_subcircuit.mapped_circuit(deep=True)
     internal_control_keys = [
         str(condition) for op in circuit.all_operations() for condition in cirq.control_keys(op)
@@ -611,9 +621,9 @@ def test_scope_flatten_outer():
     cirq.testing.assert_has_diagram(
         cirq.Circuit(outer_subcircuit),
         """
-      [       [ 0: ───M───X─── ]             ]
-0: ───[ 0: ───[       ║   ║    ]──────────── ]────────────────────────
-      [       [ a: ═══@═══^═══ ](loops=2)    ](loops=2, no_rep_ids)
+      [       [ 0: ───M───X─── ]                                      ]
+0: ───[ 0: ───[       ║   ║    ]───────────────────────────────────── ]────────────
+      [       [ a: ═══@═══^═══ ](loops=2, use_repetition_ids=True)    ](loops=2)
 """,
         use_unicode_characters=True,
     )
@@ -635,9 +645,11 @@ def test_scope_extern():
     inner = cirq.Circuit(cirq.measure(q, key='a'), cirq.X(q).with_classical_controls('b'))
     middle = cirq.Circuit(
         cirq.measure(q, key=cirq.MeasurementKey('b')),
-        cirq.CircuitOperation(inner.freeze(), repetitions=2),
+        cirq.CircuitOperation(inner.freeze(), repetitions=2, use_repetition_ids=True),
+    )
+    outer_subcircuit = cirq.CircuitOperation(
+        middle.freeze(), repetitions=2, use_repetition_ids=True
     )
-    outer_subcircuit = cirq.CircuitOperation(middle.freeze(), repetitions=2)
     circuit = outer_subcircuit.mapped_circuit(deep=True)
     internal_control_keys = [
         str(condition) for op in circuit.all_operations() for condition in cirq.control_keys(op)
@@ -645,17 +657,19 @@ def test_scope_extern():
     assert internal_control_keys == ['0:b', '0:b', '1:b', '1:b']
     assert not cirq.control_keys(outer_subcircuit)
     assert not cirq.control_keys(circuit)
+    # pylint: disable=line-too-long
     cirq.testing.assert_has_diagram(
         cirq.Circuit(outer_subcircuit),
         """
-      [           [ 0: ───M('a')───X─── ]             ]
-      [ 0: ───M───[                ║    ]──────────── ]
-0: ───[       ║   [ b: ════════════^═══ ](loops=2)    ]────────────
-      [       ║   ║                                   ]
-      [ b: ═══@═══╩══════════════════════════════════ ](loops=2)
+      [           [ 0: ───M('a')───X─── ]                                      ]
+      [ 0: ───M───[                ║    ]───────────────────────────────────── ]
+0: ───[       ║   [ b: ════════════^═══ ](loops=2, use_repetition_ids=True)    ]─────────────────────────────────────
+      [       ║   ║                                                            ]
+      [ b: ═══@═══╩═══════════════════════════════════════════════════════════ ](loops=2, use_repetition_ids=True)
 """,
         use_unicode_characters=True,
     )
+    # pylint: enable=line-too-long
     cirq.testing.assert_has_diagram(
         circuit,
         """
@@ -683,9 +697,9 @@ def test_scope_extern_wrapping_with_non_repeating_subcircuits():
     )
     middle = wrap_frozen(
         wrap(cirq.measure(q, key=cirq.MeasurementKey('b'))),
-        wrap(cirq.CircuitOperation(inner, repetitions=2)),
+        wrap(cirq.CircuitOperation(inner, repetitions=2, use_repetition_ids=True)),
     )
-    outer_subcircuit = cirq.CircuitOperation(middle, repetitions=2)
+    outer_subcircuit = cirq.CircuitOperation(middle, repetitions=2, use_repetition_ids=True)
     circuit = outer_subcircuit.mapped_circuit(deep=True)
     internal_control_keys = [
         str(condition) for op in circuit.all_operations() for condition in cirq.control_keys(op)
@@ -738,9 +752,9 @@ b: ═══╩═════════════════════
     cirq.testing.assert_has_diagram(
         circuit,
         """
-0: ───M('0:c')───M('0:0:a')───X───M('0:1:a')───X───M('1:c')───M('1:0:a')───X───M('1:1:a')───X───
-                              ║                ║                           ║                ║
-b: ═══════════════════════════^════════════════^═══════════════════════════^════════════════^═══
+0: ───M('c')───M('a')───X───M('a')───X───M('c')───M('a')───X───M('a')───X───
+                        ║            ║                     ║            ║
+b: ═════════════════════^════════════^═════════════════════^════════════^═══
 """,
         use_unicode_characters=True,
     )
@@ -752,9 +766,11 @@ def test_scope_extern_mismatch():
     inner = cirq.Circuit(cirq.measure(q, key='a'), cirq.X(q).with_classical_controls('b'))
     middle = cirq.Circuit(
         cirq.measure(q, key=cirq.MeasurementKey('b', ('0',))),
-        cirq.CircuitOperation(inner.freeze(), repetitions=2),
+        cirq.CircuitOperation(inner.freeze(), repetitions=2, use_repetition_ids=True),
+    )
+    outer_subcircuit = cirq.CircuitOperation(
+        middle.freeze(), repetitions=2, use_repetition_ids=True
     )
-    outer_subcircuit = cirq.CircuitOperation(middle.freeze(), repetitions=2)
     circuit = outer_subcircuit.mapped_circuit(deep=True)
     internal_control_keys = [
         str(condition) for op in circuit.all_operations() for condition in cirq.control_keys(op)
@@ -762,19 +778,21 @@ def test_scope_extern_mismatch():
     assert internal_control_keys == ['b', 'b', 'b', 'b']
     assert cirq.control_keys(outer_subcircuit) == {cirq.MeasurementKey('b')}
     assert cirq.control_keys(circuit) == {cirq.MeasurementKey('b')}
+    # pylint: disable=line-too-long
     cirq.testing.assert_has_diagram(
         cirq.Circuit(outer_subcircuit),
         """
-      [                  [ 0: ───M('a')───X─── ]             ]
-      [ 0: ───M('0:b')───[                ║    ]──────────── ]
-0: ───[                  [ b: ════════════^═══ ](loops=2)    ]────────────
-      [                  ║                                   ]
-      [ b: ══════════════╩══════════════════════════════════ ](loops=2)
+      [                  [ 0: ───M('a')───X─── ]                                      ]
+      [ 0: ───M('0:b')───[                ║    ]───────────────────────────────────── ]
+0: ───[                  [ b: ════════════^═══ ](loops=2, use_repetition_ids=True)    ]─────────────────────────────────────
+      [                  ║                                                            ]
+      [ b: ══════════════╩═══════════════════════════════════════════════════════════ ](loops=2, use_repetition_ids=True)
       ║
-b: ═══╩═══════════════════════════════════════════════════════════════════
+b: ═══╩═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════
 """,
         use_unicode_characters=True,
     )
+    # pylint: enable=line-too-long
     cirq.testing.assert_has_diagram(
         circuit,
         """
@@ -934,7 +952,7 @@ def test_sympy_scope():
     outer_subcircuit = cirq.CircuitOperation(middle.freeze(), repetitions=2)
     circuit = outer_subcircuit.mapped_circuit(deep=True)
     internal_controls = [str(k) for op in circuit.all_operations() for k in cirq.control_keys(op)]
-    assert set(internal_controls) == {'0:0:a', '0:1:a', '1:0:a', '1:1:a', '0:b', '1:b', 'c', 'd'}
+    assert set(internal_controls) == {'a', 'b', 'c', 'd'}
     assert cirq.control_keys(outer_subcircuit) == {'c', 'd'}
     assert cirq.control_keys(circuit) == {'c', 'd'}
     assert circuit == cirq.Circuit(cirq.decompose(outer_subcircuit))
@@ -968,23 +986,15 @@ d: ═══╩═════════════════════
     cirq.testing.assert_has_diagram(
         circuit,
         """
-0: ───────M───M('0:0:c')───M───X(conditions=[c | d, 0:0:a & 0:b])───M───X(conditions=[c | d, 0:1:a & 0:b])───M───M('1:0:c')───M───X(conditions=[c | d, 1:0:a & 1:b])───M───X(conditions=[c | d, 1:1:a & 1:b])───
-          ║                ║   ║                                    ║   ║                                    ║                ║   ║                                    ║   ║
-0:0:a: ═══╬════════════════@═══^════════════════════════════════════╬═══╬════════════════════════════════════╬════════════════╬═══╬════════════════════════════════════╬═══╬════════════════════════════════════
-          ║                    ║                                    ║   ║                                    ║                ║   ║                                    ║   ║
-0:1:a: ═══╬════════════════════╬════════════════════════════════════@═══^════════════════════════════════════╬════════════════╬═══╬════════════════════════════════════╬═══╬════════════════════════════════════
-          ║                    ║                                        ║                                    ║                ║   ║                                    ║   ║
-0:b: ═════@════════════════════^════════════════════════════════════════^════════════════════════════════════╬════════════════╬═══╬════════════════════════════════════╬═══╬════════════════════════════════════
-                               ║                                        ║                                    ║                ║   ║                                    ║   ║
-1:0:a: ════════════════════════╬════════════════════════════════════════╬════════════════════════════════════╬════════════════@═══^════════════════════════════════════╬═══╬════════════════════════════════════
-                               ║                                        ║                                    ║                    ║                                    ║   ║
-1:1:a: ════════════════════════╬════════════════════════════════════════╬════════════════════════════════════╬════════════════════╬════════════════════════════════════@═══^════════════════════════════════════
-                               ║                                        ║                                    ║                    ║                                        ║
-1:b: ══════════════════════════╬════════════════════════════════════════╬════════════════════════════════════@════════════════════^════════════════════════════════════════^════════════════════════════════════
-                               ║                                        ║                                                         ║                                        ║
-c: ════════════════════════════^════════════════════════════════════════^═════════════════════════════════════════════════════════^════════════════════════════════════════^════════════════════════════════════
-                               ║                                        ║                                                         ║                                        ║
-d: ════════════════════════════^════════════════════════════════════════^═════════════════════════════════════════════════════════^════════════════════════════════════════^════════════════════════════════════
+0: ───M───M('0:c')───M───X(conditions=[c | d, a & b])───M───X(conditions=[c | d, a & b])───M───M('0:c')───M───X(conditions=[c | d, a & b])───M───X(conditions=[c | d, a & b])───
+      ║              ║   ║                              ║   ║                              ║              ║   ║                              ║   ║
+a: ═══╬══════════════@═══^══════════════════════════════@═══^══════════════════════════════╬══════════════@═══^══════════════════════════════@═══^══════════════════════════════
+      ║                  ║                                  ║                              ║                  ║                                  ║
+b: ═══@══════════════════^══════════════════════════════════^══════════════════════════════@══════════════════^══════════════════════════════════^══════════════════════════════
+                         ║                                  ║                                                 ║                                  ║
+c: ══════════════════════^══════════════════════════════════^═════════════════════════════════════════════════^══════════════════════════════════^══════════════════════════════
+                         ║                                  ║                                                 ║                                  ║
+d: ══════════════════════^══════════════════════════════════^═════════════════════════════════════════════════^══════════════════════════════════^══════════════════════════════
 """,
         use_unicode_characters=True,
     )

cirq/protocols/json_test_data/CircuitOperation.json

@@ -133,7 +133,8 @@
     "parent_path": [],
     "repetition_ids": [
       "0"
-    ]
+    ],
+    "use_repetition_ids": true
   },
   {
     "cirq_type": "CircuitOperation",
@@ -187,7 +188,8 @@
     "repetition_ids": [
       "a",
       "b"
-    ]
+    ],
+    "use_repetition_ids": true
   },
   {
     "cirq_type": "CircuitOperation",
@@ -217,7 +219,8 @@
     "repetition_ids": [
       "a",
       "b"
-    ]
+    ],
+    "use_repetition_ids": true
   },
   {
     "cirq_type": "CircuitOperation",

cirq/protocols/json_test_data/CircuitOperation.repr_inward

@@ -25,10 +25,12 @@ cirq.CircuitOperation(circuit=cirq.FrozenCircuit([
         (cirq.X**sympy.Symbol('theta')).on(cirq.LineQubit(0)),
     ),
 ]),
-param_resolver={sympy.Symbol('theta'): 1.5}),
+param_resolver={sympy.Symbol('theta'): 1.5},
+use_repetition_ids=True),
 cirq.CircuitOperation(circuit=cirq.FrozenCircuit([
     cirq.Moment(
         (cirq.X**sympy.Symbol('theta')).on(cirq.LineQubit(0)),
     ),
 ]),
-param_resolver={sympy.Symbol('theta'): 1.5})]
+param_resolver={sympy.Symbol('theta'): 1.5},
+use_repetition_ids=True)]

{cirq_core-1.6.0.dev20250410201400.dist-info → cirq_core-1.6.0.dev20250411012134.dist-info}/METADATA

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

@@ -4,8 +4,8 @@ cirq/_compat_test.py,sha256=0m3sYIyxRNv9jvAo6rzJ-cnbpny3KGnAByrbU7bApgQ,34720
 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=JnH4bBOXKVNOCsx_84Y-fDurGCogQJPiHB8DGAgu04Q,1206
-cirq/_version_test.py,sha256=qujwhQ8xNDe0T0mtsUC-EBE6p_slGmxHXmVmOFUmOVA,147
+cirq/_version.py,sha256=zX7XCu4kNlPkS6JEKkvepOEFSSzh1XabjTWDhyFWPpo,1206
+cirq/_version_test.py,sha256=UR0yr8YBlS2K-c9Ru_qRLxtJFNoXx1kmHuL8egCWe4c,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=YVamU72nCUT5dG0bhAvRKVX5lXcZMNTwP3H36v-cYag,13615
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -17,8 +17,8 @@ cirq/circuits/_box_drawing_character_data_test.py,sha256=b3BN-iVUkQENi2Ja-RYQ_-_
 cirq/circuits/_bucket_priority_queue.py,sha256=ml98_VAwGXzASUS0hE7lT7PeA0Hugz-qAZtjtAdBsvw,6744
 cirq/circuits/_bucket_priority_queue_test.py,sha256=1FnB39rJKODvXP3SpSD6B8Tu02yQWCWOUQSPmR-22Pw,5288
 cirq/circuits/circuit.py,sha256=reDLqLMj3SZM-z-7vLZhvy4XRTnmkK0HigbknFtMDLA,119141
-cirq/circuits/circuit_operation.py,sha256=yOB9cWP2H8c8AyDrSj9FMZWsfvv_oa4z1MeaZzi_5Ws,36452
-cirq/circuits/circuit_operation_test.py,sha256=i_NZ5R9PhxjNK17DUY21rL_7O2JgVtkpn9YnWI-Ax3M,48598
+cirq/circuits/circuit_operation.py,sha256=8zeK57Xjkavt_ur9ESqocMURTcqD-f2T3hAe95gVB-g,36395
+cirq/circuits/circuit_operation_test.py,sha256=CcIX8n_aASmKR2iqWKyoCbyarEVN9WAl5VSHdBVznKg,48862
 cirq/circuits/circuit_test.py,sha256=KjRYRwUgC65vxf_3hdZLgid7sNm5Fn_lcIp15Q4yWyk,162757
 cirq/circuits/frozen_circuit.py,sha256=TLjw_UmbnV-Lhtn63RqTnCBbQiZPvsJdS-s99-aMRGI,9232
 cirq/circuits/frozen_circuit_test.py,sha256=rHyii8hLhOQ6jdA8dC1OcYPGnyeBC4uY5Q53XspkkCk,4133
@@ -273,7 +273,7 @@ cirq/ops/arithmetic_operation_test.py,sha256=iKjnwOvd1wCWk-byeUC14aGwYuHXOlkrtlO
 cirq/ops/boolean_hamiltonian.py,sha256=li003lNq6zS8pNPTobqzfzYJvyvaIpCVo3wkliI6Hzk,14930
 cirq/ops/boolean_hamiltonian_test.py,sha256=1ey5yfYZPKZDsfM3jpCPAOpbPs_y8i4K_WvDK2d5_4Y,8518
 cirq/ops/classically_controlled_operation.py,sha256=ePhBPrHymodrsztJFk_g2IGI3QSbFnpQ54d-6AH9CN4,10374
-cirq/ops/classically_controlled_operation_test.py,sha256=qS9yzhZeWmsDzg-MM-g3njvGMRWPK1muoG19A6mIcTQ,52468
+cirq/ops/classically_controlled_operation_test.py,sha256=nIYyXfNH4E2IibZSLk6QDVHpfJQbuI_iWwirCH8rhi8,50209
 cirq/ops/clifford_gate.py,sha256=hBuNKKE5kmB3W4oQxwdG1SF_NFblkcSIAUeacECRAVY,39495
 cirq/ops/clifford_gate_test.py,sha256=dqghYb7_afYxCLceBarX56Tn9y_dSWCKF75W-Qrzvcw,40341
 cirq/ops/common_channels.py,sha256=lGDOSdstoK57DingL-lo2n49-a51MshhJOl4LOcpQfg,37126
@@ -491,10 +491,10 @@ cirq/protocols/json_test_data/Circuit.json,sha256=pQNIcjuIYBfXnGkqQnn4xuSLoHysFE
 cirq/protocols/json_test_data/Circuit.json_inward,sha256=z62hEHwGtkVXrZNfxHX71_lDQ43wk12qtPO0Q0i5qwc,4574
 cirq/protocols/json_test_data/Circuit.repr,sha256=i5fwYWIi64pmupNvqEEjUn_mHKp_vVGH2ozw65_EOuw,689
 cirq/protocols/json_test_data/Circuit.repr_inward,sha256=i5fwYWIi64pmupNvqEEjUn_mHKp_vVGH2ozw65_EOuw,689
-cirq/protocols/json_test_data/CircuitOperation.json,sha256=s7jp0RDf_dz4eIvYMNDgpkoERfDBvqPWDrjWZ1Jxdck,6949
+cirq/protocols/json_test_data/CircuitOperation.json,sha256=7khipsZjJJnQQU53DgMlhG-FYzdLUCmAJcmTubby3jA,7045
 cirq/protocols/json_test_data/CircuitOperation.json_inward,sha256=EP3fiuDhxStcshrJC_Uot1hzYxEmlKk4dW66DMK9ALg,7951
 cirq/protocols/json_test_data/CircuitOperation.repr,sha256=zjkjsVG9m3jedRYhKVJG_gqhwYycaqRRCcOuk1EKWvE,1711
-cirq/protocols/json_test_data/CircuitOperation.repr_inward,sha256=rsVxASnsKEPxfJFZhXw-PPjBV_7RYTrLCglxUTXjcLY,1083
+cirq/protocols/json_test_data/CircuitOperation.repr_inward,sha256=1Ml4liM9PWg_hJ2Dr-y93XTDNklNty1RvEUwewmTdEg,1133
 cirq/protocols/json_test_data/ClassicalDataDictionaryStore.json,sha256=G09lSA5vshMhiXz_jgFw0STHjc08pJ0UczVCz8SGYLE,1185
 cirq/protocols/json_test_data/ClassicalDataDictionaryStore.repr,sha256=bOLOBw-nLRvdkd7oYcLzkh5r-cBZAxwo7H6xdDgtOHw,404
 cirq/protocols/json_test_data/ClassicallyControlledOperation.json,sha256=7t_Yyjhk8Ig-XyfOboE92K149csQbwvLoEwIsuDVHDw,669
@@ -1209,8 +1209,8 @@ cirq/work/sampler.py,sha256=sW0RhIelGABAKbqTM58shwyyCPgf86JIv9IGdJe__js,19186
 cirq/work/sampler_test.py,sha256=mdk1J-WrvbPUYhY41VhWf9_te4DnXr_XMPcugWwc4-I,13281
 cirq/work/zeros_sampler.py,sha256=8_Ne6dBkDANtTZuql7Eb0Qg_E_P3-_gu-ybFzxTbKAQ,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.6.0.dev20250410201400.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.6.0.dev20250410201400.dist-info/METADATA,sha256=GL2nKN1ltaiX0DCfqfodqAl6GAnvAdDNKftxAlrDQt4,4908
-cirq_core-1.6.0.dev20250410201400.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-cirq_core-1.6.0.dev20250410201400.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.6.0.dev20250410201400.dist-info/RECORD,,
+cirq_core-1.6.0.dev20250411012134.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.6.0.dev20250411012134.dist-info/METADATA,sha256=94Om24_IhWCE4tsmZWO4EOFbPA6guJ8VNKei8Sqww3U,4908
+cirq_core-1.6.0.dev20250411012134.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+cirq_core-1.6.0.dev20250411012134.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.6.0.dev20250411012134.dist-info/RECORD,,