cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/circuits/circuit_operation.py

@@ -18,9 +18,14 @@ A CircuitOperation is an Operation object that wraps a FrozenCircuit. When
 applied as part of a larger circuit, a CircuitOperation will execute all
 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,
     Callable,
     cast,
     Dict,
@@ -38,13 +43,12 @@ from typing import (
 import numpy as np
 import sympy
 
-from cirq import circuits, ops, protocols, value, study
+from cirq import circuits, ops, protocols, study, value
 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]
@@ -80,16 +84,16 @@ class CircuitOperation(ops.Operation):
 
     def __init__(
         self,
-        circuit: 'cirq.FrozenCircuit',
+        circuit: cirq.FrozenCircuit,
         repetitions: INT_TYPE = 1,
-        qubit_map: Optional[Dict['cirq.Qid', 'cirq.Qid']] = None,
+        qubit_map: Optional[Dict[cirq.Qid, cirq.Qid]] = None,
         measurement_key_map: Optional[Dict[str, str]] = None,
         param_resolver: Optional[study.ParamResolverOrSimilarType] = None,
         repetition_ids: Optional[Sequence[str]] = None,
         parent_path: Tuple[str, ...] = (),
-        extern_keys: FrozenSet['cirq.MeasurementKey'] = frozenset(),
-        use_repetition_ids: bool = True,
-        repeat_until: Optional['cirq.Condition'] = None,
+        extern_keys: FrozenSet[cirq.MeasurementKey] = frozenset(),
+        use_repetition_ids: Optional[bool] = None,
+        repeat_until: Optional[cirq.Condition] = None,
     ):
         """Initializes a CircuitOperation.
 
@@ -119,7 +123,9 @@ 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.
+                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.
             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
@@ -155,7 +161,19 @@ class CircuitOperation(ops.Operation):
         # Ensure that the circuit is invertible if the repetitions are negative.
         self._repetitions = repetitions
         self._repetition_ids = None if repetition_ids is None else list(repetition_ids)
-        self._use_repetition_ids = use_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
         if isinstance(self._repetitions, float):
             if math.isclose(self._repetitions, round(self._repetitions)):
                 self._repetitions = round(self._repetitions)
@@ -200,16 +218,17 @@ 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.')
 
     @property
-    def circuit(self) -> 'cirq.FrozenCircuit':
+    def circuit(self) -> cirq.FrozenCircuit:
         return self._circuit
 
     @property
@@ -225,11 +244,11 @@ class CircuitOperation(ops.Operation):
         return self._use_repetition_ids
 
     @property
-    def repeat_until(self) -> Optional['cirq.Condition']:
+    def repeat_until(self) -> Optional[cirq.Condition]:
         return self._repeat_until
 
     @property
-    def qubit_map(self) -> Mapping['cirq.Qid', 'cirq.Qid']:
+    def qubit_map(self) -> Mapping[cirq.Qid, cirq.Qid]:
         return self._qubit_map
 
     @property
@@ -244,14 +263,14 @@ class CircuitOperation(ops.Operation):
     def parent_path(self) -> Tuple[str, ...]:
         return self._parent_path
 
-    def base_operation(self) -> 'cirq.CircuitOperation':
+    def base_operation(self) -> cirq.CircuitOperation:
         """Returns a copy of this operation with only the wrapped circuit.
 
         Key and qubit mappings, parameter values, and repetitions are not copied.
         """
         return CircuitOperation(self.circuit)
 
-    def replace(self, **changes) -> 'cirq.CircuitOperation':
+    def replace(self, **changes) -> cirq.CircuitOperation:
         """Returns a copy of this operation with the specified changes."""
         kwargs = {
             'circuit': self.circuit,
@@ -266,7 +285,7 @@ class CircuitOperation(ops.Operation):
             'repeat_until': self.repeat_until,
             **changes,
         }
-        return CircuitOperation(**kwargs)  # type: ignore
+        return CircuitOperation(**kwargs)
 
     def __eq__(self, other) -> bool:
         if not isinstance(other, type(self)):
@@ -286,7 +305,7 @@ class CircuitOperation(ops.Operation):
     # Methods for getting post-mapping properties of the contained circuit.
 
     @property
-    def qubits(self) -> Tuple['cirq.Qid', ...]:
+    def qubits(self) -> Tuple[cirq.Qid, ...]:
         """Returns the qubits operated on by this object."""
         ordered_qubits = ops.QubitOrder.DEFAULT.order_for(self.circuit.all_qubits())
         return tuple(self.qubit_map.get(q, q) for q in ordered_qubits)
@@ -312,7 +331,7 @@ class CircuitOperation(ops.Operation):
             raise ValueError('Cannot unroll circuit due to nondeterministic repetitions')
 
     @cached_property
-    def _measurement_key_objs(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _measurement_key_objs(self) -> FrozenSet[cirq.MeasurementKey]:
         circuit_keys = protocols.measurement_key_objs(self.circuit)
         if circuit_keys and self.use_repetition_ids:
             self._ensure_deterministic_loop_count()
@@ -330,24 +349,25 @@ class CircuitOperation(ops.Operation):
             for key in circuit_keys
         )
 
-    def _measurement_key_objs_(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _measurement_key_objs_(self) -> FrozenSet[cirq.MeasurementKey]:
         return self._measurement_key_objs
 
     def _measurement_key_names_(self) -> FrozenSet[str]:
         return frozenset(str(key) for key in self._measurement_key_objs_())
 
     @cached_property
-    def _control_keys(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _control_keys(self) -> FrozenSet[cirq.MeasurementKey]:
         keys = (
             frozenset()
             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']:
+    def _control_keys_(self) -> FrozenSet[cirq.MeasurementKey]:
         return self._control_keys
 
     def _is_parameterized_(self) -> bool:
@@ -358,14 +378,11 @@ 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':
+    def _mapped_any_loop(self) -> cirq.Circuit:
         circuit = self.circuit.unfreeze()
         if self.qubit_map:
             circuit = circuit.transform_qubits(lambda q: self.qubit_map.get(q, q))
@@ -377,7 +394,7 @@ class CircuitOperation(ops.Operation):
             circuit = protocols.resolve_parameters(circuit, self.param_resolver, recursive=False)
         return circuit.unfreeze(copy=False)
 
-    def _mapped_single_loop(self, repetition_id: Optional[str] = None) -> 'cirq.Circuit':
+    def _mapped_single_loop(self, repetition_id: Optional[str] = None) -> cirq.Circuit:
         circuit = self._mapped_any_loop
         if repetition_id:
             circuit = protocols.with_rescoped_keys(circuit, (repetition_id,))
@@ -385,7 +402,27 @@ class CircuitOperation(ops.Operation):
             circuit, self.parent_path, bindable_keys=self._extern_keys
         )
 
-    def mapped_circuit(self, deep: bool = False) -> 'cirq.Circuit':
+    @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.
 
         Args:
@@ -413,20 +450,21 @@ class CircuitOperation(ops.Operation):
             )
         return circuit
 
-    def mapped_op(self, deep: bool = False) -> 'cirq.CircuitOperation':
+    def mapped_op(self, deep: bool = False) -> cirq.CircuitOperation:
         """As `mapped_circuit`, but wraps the result in a CircuitOperation."""
         return CircuitOperation(circuit=self.mapped_circuit(deep=deep).freeze())
 
-    def _decompose_(self) -> Iterator['cirq.Operation']:
+    def _decompose_(self) -> Iterator[cirq.Operation]:
         return self.mapped_circuit(deep=False).all_operations()
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase') -> bool:
-        if self.repeat_until:
+    def _act_on_(self, sim_state: cirq.SimulationStateBase) -> bool:
+        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_():
@@ -508,6 +546,16 @@ class CircuitOperation(ops.Operation):
     def __hash__(self) -> int:
         return self._hash
 
+    def __getstate__(self) -> Dict[str, Any]:
+        # clear cached hash value when pickling, see #6674
+        state = self.__dict__
+        # cached_property stores value in the property-named attribute
+        hash_attr = "_hash"
+        if hash_attr in state:
+            state = state.copy()
+            del state[hash_attr]
+        return state
+
     def _json_dict_(self):
         resp = {
             'circuit': self.circuit,
@@ -556,7 +604,7 @@ class CircuitOperation(ops.Operation):
 
     def repeat(
         self, repetitions: Optional[IntParam] = None, repetition_ids: Optional[Sequence[str]] = None
-    ) -> 'CircuitOperation':
+    ) -> CircuitOperation:
         """Returns a copy of this operation repeated 'repetitions' times.
          Each repetition instance will be identified by a single repetition_id.
 
@@ -608,7 +656,7 @@ class CircuitOperation(ops.Operation):
         final_repetitions = protocols.mul(self.repetitions, repetitions)
         return self.replace(repetitions=final_repetitions, repetition_ids=repetition_ids)
 
-    def __pow__(self, power: IntParam) -> 'cirq.CircuitOperation':
+    def __pow__(self, power: IntParam) -> cirq.CircuitOperation:
         return self.repeat(power)
 
     def _with_key_path_(self, path: Tuple[str, ...]):
@@ -618,7 +666,7 @@ class CircuitOperation(ops.Operation):
         return self.replace(parent_path=prefix + self.parent_path)
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
+        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
     ):
         # The following line prevents binding to measurement keys in previous repeated subcircuits
         # "just because their repetition ids matched". If we eventually decide to change that
@@ -642,7 +690,7 @@ class CircuitOperation(ops.Operation):
         """
         return self._with_key_path_(path)
 
-    def with_repetition_ids(self, repetition_ids: List[str]) -> 'cirq.CircuitOperation':
+    def with_repetition_ids(self, repetition_ids: List[str]) -> cirq.CircuitOperation:
         """Returns a copy of this `CircuitOperation` with the given repetition IDs.
 
         Args:
@@ -655,8 +703,8 @@ class CircuitOperation(ops.Operation):
         return self.replace(repetition_ids=repetition_ids)
 
     def with_qubit_mapping(
-        self, qubit_map: Union[Mapping['cirq.Qid', 'cirq.Qid'], Callable[['cirq.Qid'], 'cirq.Qid']]
-    ) -> 'cirq.CircuitOperation':
+        self, qubit_map: Union[Mapping[cirq.Qid, cirq.Qid], Callable[[cirq.Qid], cirq.Qid]]
+    ) -> cirq.CircuitOperation:
         """Returns a copy of this operation with an updated qubit mapping.
 
         Users should pass either 'qubit_map' or 'transform' to this method.
@@ -677,7 +725,7 @@ class CircuitOperation(ops.Operation):
         if callable(qubit_map):
             transform = qubit_map
         elif isinstance(qubit_map, dict):
-            transform = lambda q: qubit_map.get(q, q)  # type: ignore
+            transform = lambda q: qubit_map.get(q, q)
         else:
             raise TypeError('qubit_map must be a function or dict mapping qubits to qubits.')
         new_map = {}
@@ -695,7 +743,7 @@ class CircuitOperation(ops.Operation):
             )
         return new_op
 
-    def with_qubits(self, *new_qubits: 'cirq.Qid') -> 'cirq.CircuitOperation':
+    def with_qubits(self, *new_qubits: cirq.Qid) -> cirq.CircuitOperation:
         """Returns a copy of this operation with an updated qubit mapping.
 
         Args:
@@ -715,7 +763,7 @@ class CircuitOperation(ops.Operation):
             raise ValueError(f'Expected {expected} qubits, got {len(new_qubits)}.')
         return self.with_qubit_mapping(dict(zip(self.qubits, new_qubits)))
 
-    def with_measurement_key_mapping(self, key_map: Mapping[str, str]) -> 'cirq.CircuitOperation':
+    def with_measurement_key_mapping(self, key_map: Mapping[str, str]) -> cirq.CircuitOperation:
         """Returns a copy of this operation with an updated key mapping.
 
         Args:
@@ -749,12 +797,12 @@ class CircuitOperation(ops.Operation):
             )
         return new_op
 
-    def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> 'cirq.CircuitOperation':
+    def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> cirq.CircuitOperation:
         return self.with_measurement_key_mapping(key_map)
 
     def with_params(
-        self, param_values: 'cirq.ParamResolverOrSimilarType', recursive: bool = False
-    ) -> 'cirq.CircuitOperation':
+        self, param_values: cirq.ParamResolverOrSimilarType, recursive: bool = False
+    ) -> cirq.CircuitOperation:
         """Returns a copy of this operation with an updated ParamResolver.
 
         Any existing parameter mappings will have their values updated given
@@ -780,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:
@@ -788,8 +838,8 @@ class CircuitOperation(ops.Operation):
         return self.replace(param_resolver=new_params)
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.CircuitOperation':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> cirq.CircuitOperation:
         resolved = self.with_params(resolver.param_dict, recursive)
         # repetitions can resolve to a float, but this is ok since constructor converts to
         # nearby int.

cirq/circuits/circuit_operation_test.py

@@ -168,7 +168,7 @@ def test_with_qubits():
 
     assert op_base.with_qubit_mapping({a: d, b: c, d: a}) == op_with_qubits
 
-    def map_fn(qubit: 'cirq.Qid') -> 'cirq.Qid':
+    def map_fn(qubit: cirq.Qid) -> cirq.Qid:
         if qubit == a:
             return d
         if qubit == b:
@@ -327,9 +327,33 @@ def test_repeat(add_measurements: bool, use_default_ids_for_initial_rep: bool) -
         _ = op_base.repeat()
 
     with pytest.raises(TypeError, match='Only integer or sympy repetitions are allowed'):
-        _ = op_base.repeat(1.3)  # type: ignore[arg-type]
-    assert op_base.repeat(3.00000000001).repetitions == 3  # type: ignore[arg-type]
-    assert op_base.repeat(2.99999999999).repetitions == 3  # type: ignore[arg-type]
+        _ = op_base.repeat(1.3)
+    assert op_base.repeat(3.00000000001).repetitions == 3
+    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'))
+    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])
@@ -1204,4 +1228,61 @@ 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)),
+        # 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,
+    # 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)),
+        # 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.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?