cirq-core 1.5.0.dev20250129170403__py3-none-any.whl → 1.5.0.dev20250130015503__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.5.0.dev20250129170403"
+__version__ = "1.5.0.dev20250130015503"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.5.0.dev20250129170403"
+    assert cirq.__version__ == "1.5.0.dev20250130015503"

cirq/circuits/circuit_operation.py

@@ -204,11 +204,12 @@ class CircuitOperation(ops.Operation):
                 )
 
         self._repeat_until = repeat_until
-        if self._repeat_until:
+        mapped_repeat_until = self._mapped_repeat_until
+        if mapped_repeat_until:
             if self._use_repetition_ids or self._repetitions != 1:
                 raise ValueError('Cannot use repetitions with repeat_until')
             if protocols.measurement_key_objs(self._mapped_single_loop()).isdisjoint(
-                self._repeat_until.keys
+                mapped_repeat_until.keys
             ):
                 raise ValueError('Infinite loop: condition is not modified in subcircuit.')
 
@@ -266,7 +267,9 @@ class CircuitOperation(ops.Operation):
             'repetition_ids': self.repetition_ids,
             'parent_path': self.parent_path,
             'extern_keys': self._extern_keys,
-            'use_repetition_ids': True if 'repetition_ids' in changes else 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,
         }
@@ -347,8 +350,9 @@ class CircuitOperation(ops.Operation):
             if not protocols.control_keys(self.circuit)
             else protocols.control_keys(self._mapped_single_loop())
         )
-        if self.repeat_until is not None:
-            keys |= frozenset(self.repeat_until.keys) - self._measurement_key_objs_()
+        mapped_repeat_until = self._mapped_repeat_until
+        if mapped_repeat_until is not None:
+            keys |= frozenset(mapped_repeat_until.keys) - self._measurement_key_objs_()
         return keys
 
     def _control_keys_(self) -> FrozenSet['cirq.MeasurementKey']:
@@ -362,11 +366,8 @@ class CircuitOperation(ops.Operation):
 
     def _parameter_names_generator(self) -> Iterator[str]:
         yield from protocols.parameter_names(self.repetitions)
-        for symbol in protocols.parameter_symbols(self.circuit):
-            for name in protocols.parameter_names(
-                protocols.resolve_parameters(symbol, self.param_resolver, recursive=False)
-            ):
-                yield name
+        yield from protocols.parameter_names(self._mapped_repeat_until)
+        yield from protocols.parameter_names(self._mapped_any_loop)
 
     @cached_property
     def _mapped_any_loop(self) -> 'cirq.Circuit':
@@ -389,6 +390,26 @@ class CircuitOperation(ops.Operation):
             circuit, self.parent_path, bindable_keys=self._extern_keys
         )
 
+    @cached_property
+    def _mapped_repeat_until(self) -> Optional['cirq.Condition']:
+        """Applies measurement_key_map, param_resolver, and current scope to repeat_until."""
+        repeat_until = self.repeat_until
+        if not repeat_until:
+            return repeat_until
+        if self.measurement_key_map:
+            repeat_until = protocols.with_measurement_key_mapping(
+                repeat_until, self.measurement_key_map
+            )
+        if self.param_resolver:
+            repeat_until = protocols.resolve_parameters(
+                repeat_until, self.param_resolver, recursive=False
+            )
+        return protocols.with_rescoped_keys(
+            repeat_until,
+            self.parent_path,
+            bindable_keys=self._extern_keys | self._measurement_key_objs,
+        )
+
     def mapped_circuit(self, deep: bool = False) -> 'cirq.Circuit':
         """Applies all maps to the contained circuit and returns the result.
 
@@ -425,12 +446,13 @@ class CircuitOperation(ops.Operation):
         return self.mapped_circuit(deep=False).all_operations()
 
     def _act_on_(self, sim_state: 'cirq.SimulationStateBase') -> bool:
-        if self.repeat_until:
+        mapped_repeat_until = self._mapped_repeat_until
+        if mapped_repeat_until:
             circuit = self._mapped_single_loop()
             while True:
                 for op in circuit.all_operations():
                     protocols.act_on(op, sim_state)
-                if self.repeat_until.resolve(sim_state.classical_data):
+                if mapped_repeat_until.resolve(sim_state.classical_data):
                     break
         else:
             for op in self._decompose_():
@@ -806,7 +828,9 @@ class CircuitOperation(ops.Operation):
                 by param_values.
         """
         new_params = {}
-        for k in protocols.parameter_symbols(self.circuit):
+        for k in protocols.parameter_symbols(self.circuit) | protocols.parameter_symbols(
+            self.repeat_until
+        ):
             v = self.param_resolver.value_of(k, recursive=False)
             v = protocols.resolve_parameters(v, param_values, recursive=recursive)
             if v != k:

cirq/circuits/circuit_operation_test.py

@@ -332,6 +332,28 @@ def test_repeat(add_measurements: bool, use_default_ids_for_initial_rep: bool) -
     assert op_base.repeat(2.99999999999).repetitions == 3
 
 
+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'))
+    op = cirq.CircuitOperation(circuit.freeze())
+    assert op.repetitions == 1
+    assert not op.use_repetition_ids
+
+    op2 = op.replace(repetitions=2)
+    assert op2.repetitions == 2
+    assert not op2.use_repetition_ids
+
+    op3 = op.replace(repetitions=3, repetition_ids=None)
+    assert op3.repetitions == 3
+    assert not op3.use_repetition_ids
+
+    # Passing `repetition_ids` will also enable `use_repetition_ids`
+    op4 = op.replace(repetitions=4, repetition_ids=['a', 'b', 'c', 'd'])
+    assert op4.repetitions == 4
+    assert op4.use_repetition_ids
+    assert op4.repetition_ids == ['a', 'b', 'c', 'd']
+
+
 @pytest.mark.parametrize('add_measurements', [True, False])
 @pytest.mark.parametrize('use_repetition_ids', [True, False])
 @pytest.mark.parametrize('initial_reps', [0, 1, 2, 3])
@@ -1217,4 +1239,57 @@ def test_repeat_until_error():
         )
 
 
+def test_repeat_until_protocols():
+    q = cirq.LineQubit(0)
+    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)),
+    )
+    scoped = cirq.with_rescoped_keys(op, ('0',))
+    # Ensure the _repeat_until has been mapped, the measurement has been mapped to the same key,
+    # and the control keys of the subcircuit is empty (because the control key of the condition is
+    # bound to the measurement).
+    assert scoped._mapped_repeat_until.keys == (cirq.MeasurementKey('a', ('0',)),)
+    assert cirq.measurement_key_objs(scoped) == {cirq.MeasurementKey('a', ('0',))}
+    assert not cirq.control_keys(scoped)
+    mapped = cirq.with_measurement_key_mapping(scoped, {'a': 'b'})
+    assert mapped._mapped_repeat_until.keys == (cirq.MeasurementKey('b', ('0',)),)
+    assert cirq.measurement_key_objs(mapped) == {cirq.MeasurementKey('b', ('0',))}
+    assert not cirq.control_keys(mapped)
+    prefixed = cirq.with_key_path_prefix(mapped, ('1',))
+    assert prefixed._mapped_repeat_until.keys == (cirq.MeasurementKey('b', ('1', '0')),)
+    assert cirq.measurement_key_objs(prefixed) == {cirq.MeasurementKey('b', ('1', '0'))}
+    assert not cirq.control_keys(prefixed)
+    setpath = cirq.with_key_path(prefixed, ('2',))
+    assert setpath._mapped_repeat_until.keys == (cirq.MeasurementKey('b', ('2',)),)
+    assert cirq.measurement_key_objs(setpath) == {cirq.MeasurementKey('b', ('2',))}
+    assert not cirq.control_keys(setpath)
+    resolved = cirq.resolve_parameters(setpath, {'p': 1})
+    assert resolved._mapped_repeat_until.keys == (cirq.MeasurementKey('b', ('2',)),)
+    assert cirq.measurement_key_objs(resolved) == {cirq.MeasurementKey('b', ('2',))}
+    assert not cirq.control_keys(resolved)
+
+
+def test_inner_repeat_until_simulate():
+    sim = cirq.Simulator()
+    q = cirq.LineQubit(0)
+    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)),
+    )
+    outer_loop = cirq.Circuit(inner_loop, cirq.X(q), cirq.measure(q, key="outer_loop"))
+    circuit = cirq.Circuit(
+        cirq.CircuitOperation(
+            cirq.FrozenCircuit(outer_loop), repetitions=2, use_repetition_ids=True
+        )
+    )
+    result = sim.run(circuit, repetitions=1)
+    assert all(len(v) == 1 and v[0] == 1 for v in result.records['0:inner_loop'][0][:-1])
+    assert result.records['0:inner_loop'][0][-1] == [0]
+    assert result.records['0:outer_loop'] == [[[1]]]
+    assert all(len(v) == 1 and v[0] == 1 for v in result.records['1:inner_loop'][0][:-1])
+    assert result.records['1:inner_loop'][0][-1] == [0]
+    assert result.records['1:outer_loop'] == [[[1]]]
+
+
 # TODO: Operation has a "gate" property. What is this for a CircuitOperation?

{cirq_core-1.5.0.dev20250129170403.dist-info → cirq_core-1.5.0.dev20250130015503.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20250129170403
+Version: 1.5.0.dev20250130015503
 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.5.0.dev20250129170403.dist-info → cirq_core-1.5.0.dev20250130015503.dist-info}/RECORD

@@ -4,8 +4,8 @@ cirq/_compat_test.py,sha256=Qq3ZcfgD-Nb81cEppQdJqhAyrVqXKtfXZYGXT0p-Wh0,34718
 cirq/_doc.py,sha256=yDyWUD_2JDS0gShfGRb-rdqRt9-WeL7DhkqX7np0Nko,2879
 cirq/_import.py,sha256=p9gMHJscbtDDkfHOaulvd3Aer0pwUF5AXpL89XR8dNw,8402
 cirq/_import_test.py,sha256=6K_v0riZJXOXUphHNkGA8MY-JcmGlezFaGmvrNhm3OQ,1015
-cirq/_version.py,sha256=g1SwSxTTMRqe0SCQLN4jCqEoiAGb7QqZlMPwn2FHAWQ,1206
-cirq/_version_test.py,sha256=JJvDW9aVU9QjyAclatis4-vc9z7aHTqYlpp0ZW4Yshc,147
+cirq/_version.py,sha256=Z3MeetPG8uFdenZ8lUi6QnXnRi17cW83EK8ooyUVaqU,1206
+cirq/_version_test.py,sha256=z9D3sbZSuBjDrgV9H6P-omFuNl3Tu0cKLKbtrPGAz-8,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=p-vEOa-8GQ2cFIAdze-kd6C1un1uRvtujVPljVKaHBg,13557
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -17,8 +17,8 @@ cirq/circuits/_box_drawing_character_data_test.py,sha256=XO94z0piwZRHaNZHTf-5tKH
 cirq/circuits/_bucket_priority_queue.py,sha256=hxFuii2fKD8G6EKT_aVLEsA7FmSfqFXPwIbA0KsoSC4,6745
 cirq/circuits/_bucket_priority_queue_test.py,sha256=t6u_hG7K2e2WKWrgCsKxNRtp4ghKwiCrp0_WSY0W25k,5288
 cirq/circuits/circuit.py,sha256=nbWC95tzQlm69JmvFJdJMwzDOia_s0pah8tH4i9u1Ug,118173
-cirq/circuits/circuit_operation.py,sha256=MaQ6fPt1HctEE31fVaUDtl9MqOmoTyt3m2HYeGCdIaM,35440
-cirq/circuits/circuit_operation_test.py,sha256=7ezTwTY2RaAchjfXOJythVrxs6Rom317gC0AUBe0GVM,45259
+cirq/circuits/circuit_operation.py,sha256=ebI2KBvQLcBYgjQXKO6y6jB2EDLgwtxdZBRs3hSYaLM,36438
+cirq/circuits/circuit_operation_test.py,sha256=SFyM12Ky7-OVwl-jK3OTMMN0DD5hR6tWfx_v7m6HUMo,48866
 cirq/circuits/circuit_test.py,sha256=BZjwavIekWR2hgG1yV0Acgt7-Q05cOjugozrLgYdx7k,161268
 cirq/circuits/frozen_circuit.py,sha256=qSbLHqIszCbVipNZQy4N829v_mWf8N2926cYRzpxGqE,9243
 cirq/circuits/frozen_circuit_test.py,sha256=rHyii8hLhOQ6jdA8dC1OcYPGnyeBC4uY5Q53XspkkCk,4133
@@ -1202,8 +1202,8 @@ cirq/work/sampler.py,sha256=bE5tmVkcR6cZZMLETxDfHehdsYUMbx2RvBeIBetehI4,19187
 cirq/work/sampler_test.py,sha256=hL2UWx3dz2ukZVNxWftiKVvJcQoLplLZdQm-k1QcA40,13282
 cirq/work/zeros_sampler.py,sha256=x1C7cup66a43n-3tm8QjhiqJa07qcJW10FxNp9jJ59Q,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.5.0.dev20250129170403.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250129170403.dist-info/METADATA,sha256=clZcpQi-Nc34xIBgsUaiId0cvJ_5WpR1BErlWzJMi3E,3239
-cirq_core-1.5.0.dev20250129170403.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250129170403.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250129170403.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250130015503.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250130015503.dist-info/METADATA,sha256=-pHqgurSc5x5vO1o8MvoRkzRl1QgSLjhSxEBZJFoNrg,3239
+cirq_core-1.5.0.dev20250130015503.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250130015503.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250130015503.dist-info/RECORD,,