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

cirq/circuits/circuit_test.py

@@ -11,20 +11,20 @@
 # 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 itertools
 import os
 import time
 from collections import defaultdict
-from random import randint, random, sample, randrange
-from typing import Iterator, Optional, Tuple, TYPE_CHECKING
+from random import randint, random, randrange, sample
+from typing import Iterator, Optional, Tuple
 
 import numpy as np
 import pytest
 import sympy
 
 import cirq
-from cirq import circuits
-from cirq import ops
+from cirq import circuits, ops
 from cirq.testing.devices import ValidatingTestDevice
 
 
@@ -50,25 +50,9 @@ BCONE = ValidatingTestDevice(
 )
 
 
-if TYPE_CHECKING:
-    import cirq
-
 q0, q1, q2, q3 = cirq.LineQubit.range(4)
 
 
-class _MomentAndOpTypeValidatingDeviceType(cirq.Device):
-    def validate_operation(self, operation):
-        if not isinstance(operation, cirq.Operation):
-            raise ValueError(f'not isinstance({operation!r}, {cirq.Operation!r})')
-
-    def validate_moment(self, moment):
-        if not isinstance(moment, cirq.Moment):
-            raise ValueError(f'not isinstance({moment!r}, {cirq.Moment!r})')
-
-
-moment_and_op_type_validating_device = _MomentAndOpTypeValidatingDeviceType()
-
-
 def test_from_moments():
     a, b, c, d = cirq.LineQubit.range(4)
     moment = cirq.Moment(cirq.Z(a), cirq.Z(b))
@@ -80,6 +64,7 @@ def test_from_moments():
         [cirq.X(c)],
         [],
         cirq.Z(d),
+        None,
         [cirq.measure(a, b, key='ab'), cirq.measure(c, d, key='cd')],
     )
     assert circuit == cirq.Circuit(
@@ -906,8 +891,8 @@ def test_insert_at_frontier():
             self.replacer = replacer
 
         def optimization_at(
-            self, circuit: 'cirq.Circuit', index: int, op: 'cirq.Operation'
-        ) -> Optional['cirq.PointOptimizationSummary']:
+            self, circuit: cirq.Circuit, index: int, op: cirq.Operation
+        ) -> Optional[cirq.PointOptimizationSummary]:
             new_ops = self.replacer(op)
             return cirq.PointOptimizationSummary(
                 clear_span=1, clear_qubits=op.qubits, new_operations=new_ops
@@ -3554,6 +3539,52 @@ def test_insert_operations_random_circuits(circuit):
     assert circuit == other_circuit
 
 
+def test_insert_zero_index():
+    # Should always go to moment[0], independent of qubit order or earliest/inline strategy.
+    q0, q1 = cirq.LineQubit.range(2)
+    c0 = cirq.Circuit(cirq.X(q0))
+    c0.insert(0, cirq.Y.on_each(q0, q1), strategy=cirq.InsertStrategy.EARLIEST)
+    c1 = cirq.Circuit(cirq.X(q0))
+    c1.insert(0, cirq.Y.on_each(q1, q0), strategy=cirq.InsertStrategy.EARLIEST)
+    c2 = cirq.Circuit(cirq.X(q0))
+    c2.insert(0, cirq.Y.on_each(q0, q1), strategy=cirq.InsertStrategy.INLINE)
+    c3 = cirq.Circuit(cirq.X(q0))
+    c3.insert(0, cirq.Y.on_each(q1, q0), strategy=cirq.InsertStrategy.INLINE)
+    expected = cirq.Circuit(cirq.Moment(cirq.Y(q0), cirq.Y(q1)), cirq.Moment(cirq.X(q0)))
+    assert c0 == expected
+    assert c1 == expected
+    assert c2 == expected
+    assert c3 == expected
+
+
+def test_insert_earliest_on_previous_moment():
+    q = cirq.LineQubit(0)
+    c = cirq.Circuit(cirq.Moment(cirq.X(q)), cirq.Moment(), cirq.Moment(), cirq.Moment(cirq.Z(q)))
+    c.insert(3, cirq.Y(q), strategy=cirq.InsertStrategy.EARLIEST)
+    # Should fall back to moment[1] since EARLIEST
+    assert c == cirq.Circuit(
+        cirq.Moment(cirq.X(q)), cirq.Moment(cirq.Y(q)), cirq.Moment(), cirq.Moment(cirq.Z(q))
+    )
+
+
+def test_insert_inline_end_of_circuit():
+    # If end index is specified, INLINE should place all ops there independent of qubit order.
+    q0, q1 = cirq.LineQubit.range(2)
+    c0 = cirq.Circuit(cirq.X(q0))
+    c0.insert(1, cirq.Y.on_each(q0, q1), strategy=cirq.InsertStrategy.INLINE)
+    c1 = cirq.Circuit(cirq.X(q0))
+    c1.insert(1, cirq.Y.on_each(q1, q0), strategy=cirq.InsertStrategy.INLINE)
+    c2 = cirq.Circuit(cirq.X(q0))
+    c2.insert(5, cirq.Y.on_each(q0, q1), strategy=cirq.InsertStrategy.INLINE)
+    c3 = cirq.Circuit(cirq.X(q0))
+    c3.insert(5, cirq.Y.on_each(q1, q0), strategy=cirq.InsertStrategy.INLINE)
+    expected = cirq.Circuit(cirq.Moment(cirq.X(q0)), cirq.Moment(cirq.Y(q0), cirq.Y(q1)))
+    assert c0 == expected
+    assert c1 == expected
+    assert c2 == expected
+    assert c3 == expected
+
+
 def test_insert_operations_errors():
     a, b, c = (cirq.NamedQubit(s) for s in 'abc')
     with pytest.raises(ValueError):
@@ -3578,7 +3609,7 @@ def test_insert_operations_errors():
 @pytest.mark.parametrize('circuit_cls', [cirq.Circuit, cirq.FrozenCircuit])
 def test_to_qasm(circuit_cls):
     q0 = cirq.NamedQubit('q0')
-    circuit = circuit_cls(cirq.X(q0))
+    circuit = circuit_cls(cirq.X(q0), cirq.measure(q0, key='mmm'))
     assert circuit.to_qasm() == cirq.qasm(circuit)
     assert (
         circuit.to_qasm()
@@ -3590,9 +3621,29 @@ include "qelib1.inc";
 
 // Qubits: [q0]
 qreg q[1];
+creg m_mmm[1];
+
+
+x q[0];
+measure q[0] -> m_mmm[0];
+"""
+    )
+    assert circuit.to_qasm(version="3.0") == cirq.qasm(circuit, args=cirq.QasmArgs(version="3.0"))
+    assert (
+        circuit.to_qasm(version="3.0")
+        == f"""// Generated from Cirq v{cirq.__version__}
+
+OPENQASM 3.0;
+include "stdgates.inc";
+
+
+// Qubits: [q0]
+qubit[1] q;
+bit[1] m_mmm;
 
 
 x q[0];
+m_mmm[0] = measure q[0];
 """
     )
 
@@ -4824,18 +4875,36 @@ global phase:   0.5π
 def test_create_speed():
     # Added in https://github.com/quantumlib/Cirq/pull/5332
     # Previously this took ~30s to run. Now it should take ~150ms. However the coverage test can
-    # run this slowly, so allowing 2 sec to account for things like that. Feel free to increase the
+    # run this slowly, so allowing 4 sec to account for things like that. Feel free to increase the
     # buffer time or delete the test entirely if it ends up causing flakes.
-    #
-    # Updated in https://github.com/quantumlib/Cirq/pull/5756
-    # After several tiny overtime failures of the GitHub CI Pytest MacOS (3.7)
-    # the timeout was increased to 4 sec.  A more thorough investigation or test
-    # removal should be considered if this continues to time out.
     qs = 100
     moments = 500
     xs = [cirq.X(cirq.LineQubit(i)) for i in range(qs)]
-    opa = [xs[i] for i in range(qs) for _ in range(moments)]
+    ops = [xs[i] for i in range(qs) for _ in range(moments)]
+    t = time.perf_counter()
+    c = cirq.Circuit(ops)
+    duration = time.perf_counter() - t
+    assert len(c) == moments
+    assert duration < 4
+
+
+def test_append_speed():
+    # Previously this took ~17s to run. Now it should take ~150ms. However the coverage test can
+    # run this slowly, so allowing 5 sec to account for things like that. Feel free to increase the
+    # buffer time or delete the test entirely if it ends up causing flakes.
+    #
+    # The `append` improvement mainly helps for deep circuits. It is less useful for wide circuits
+    # because the Moment (immutable) needs verified and reconstructed each time an op is added.
+    qs = 2
+    moments = 10000
+    xs = [cirq.X(cirq.LineQubit(i)) for i in range(qs)]
+    c = cirq.Circuit()
     t = time.perf_counter()
-    c = cirq.Circuit(opa)
+    # Iterating with the moments in the inner loop highlights the improvement: when filling in the
+    # second qubit, we no longer have to search backwards from moment 10000 for a placement index.
+    for q in range(qs):
+        for _ in range(moments):
+            c.append(xs[q])
+    duration = time.perf_counter() - t
     assert len(c) == moments
-    assert time.perf_counter() - t < 4
+    assert duration < 5

cirq/circuits/frozen_circuit.py

@@ -11,8 +11,13 @@
 # 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.
+
 """An immutable version of the Circuit data structure."""
+
+from __future__ import annotations
+
 from functools import cached_property
+from types import NotImplementedType
 from typing import (
     AbstractSet,
     FrozenSet,
@@ -27,10 +32,9 @@ from typing import (
 
 import numpy as np
 
-from cirq import protocols, _compat
+from cirq import _compat, protocols
 from cirq.circuits import AbstractCircuit, Alignment, Circuit
 from cirq.circuits.insert_strategy import InsertStrategy
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq
@@ -46,8 +50,8 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
 
     def __init__(
         self,
-        *contents: 'cirq.OP_TREE',
-        strategy: 'cirq.InsertStrategy' = InsertStrategy.EARLIEST,
+        *contents: cirq.OP_TREE,
+        strategy: cirq.InsertStrategy = InsertStrategy.EARLIEST,
         tags: Sequence[Hashable] = (),
     ) -> None:
         """Initializes a frozen circuit.
@@ -71,20 +75,20 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         self._tags = tuple(tags)
 
     @classmethod
-    def _from_moments(cls, moments: Iterable['cirq.Moment']) -> 'FrozenCircuit':
+    def _from_moments(cls, moments: Iterable[cirq.Moment]) -> FrozenCircuit:
         new_circuit = FrozenCircuit()
         new_circuit._moments = tuple(moments)
         return new_circuit
 
     @property
-    def moments(self) -> Sequence['cirq.Moment']:
+    def moments(self) -> Sequence[cirq.Moment]:
         return self._moments
 
-    def freeze(self) -> 'cirq.FrozenCircuit':
+    def freeze(self) -> cirq.FrozenCircuit:
         return self
 
-    def unfreeze(self, copy: bool = True) -> 'cirq.Circuit':
-        return Circuit.from_moments(*self)
+    def unfreeze(self, copy: bool = True) -> cirq.Circuit:
+        return Circuit._from_moments(self._moments)
 
     @property
     def tags(self) -> Tuple[Hashable, ...]:
@@ -92,11 +96,11 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return self._tags
 
     @cached_property
-    def untagged(self) -> 'cirq.FrozenCircuit':
+    def untagged(self) -> cirq.FrozenCircuit:
         """Returns the underlying FrozenCircuit without any tags."""
         return self._from_moments(self._moments) if self.tags else self
 
-    def with_tags(self, *new_tags: Hashable) -> 'cirq.FrozenCircuit':
+    def with_tags(self, *new_tags: Hashable) -> cirq.FrozenCircuit:
         """Creates a new tagged `FrozenCircuit` with `self.tags` and `new_tags` combined."""
         if not new_tags:
             return self
@@ -119,10 +123,10 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
     def __getstate__(self):
         # Don't save hash when pickling; see #3777.
         state = self.__dict__
-        hash_cache = _compat._method_cache_name(self.__hash__)
-        if hash_cache in state:
+        hash_attr = _compat._method_cache_name(self.__hash__)
+        if hash_attr in state:
             state = state.copy()
-            del state[hash_cache]
+            del state[hash_attr]
         return state
 
     @_compat.cached_method
@@ -146,28 +150,28 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return protocols.is_measurement(self.unfreeze())
 
     @_compat.cached_method
-    def all_qubits(self) -> FrozenSet['cirq.Qid']:
+    def all_qubits(self) -> FrozenSet[cirq.Qid]:
         return super().all_qubits()
 
     @cached_property
-    def _all_operations(self) -> Tuple['cirq.Operation', ...]:
+    def _all_operations(self) -> Tuple[cirq.Operation, ...]:
         return tuple(super().all_operations())
 
-    def all_operations(self) -> Iterator['cirq.Operation']:
+    def all_operations(self) -> Iterator[cirq.Operation]:
         return iter(self._all_operations)
 
     def has_measurements(self) -> bool:
         return self._is_measurement_()
 
     @_compat.cached_method
-    def all_measurement_key_objs(self) -> FrozenSet['cirq.MeasurementKey']:
+    def all_measurement_key_objs(self) -> FrozenSet[cirq.MeasurementKey]:
         return super().all_measurement_key_objs()
 
-    def _measurement_key_objs_(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _measurement_key_objs_(self) -> FrozenSet[cirq.MeasurementKey]:
         return self.all_measurement_key_objs()
 
     @_compat.cached_method
-    def _control_keys_(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _control_keys_(self) -> FrozenSet[cirq.MeasurementKey]:
         return super()._control_keys_()
 
     @_compat.cached_method
@@ -190,8 +194,8 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return super()._parameter_names_() | tag_params
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.FrozenCircuit':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> cirq.FrozenCircuit:
         resolved_circuit = super()._resolve_parameters_(resolver, recursive)
         resolved_tags = [
             protocols.resolve_parameters(tag, resolver, recursive) for tag in self.tags
@@ -201,23 +205,23 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
     def _measurement_key_names_(self) -> FrozenSet[str]:
         return self.all_measurement_key_names()
 
-    def __add__(self, other) -> 'cirq.FrozenCircuit':
+    def __add__(self, other) -> cirq.FrozenCircuit:
         return (self.unfreeze() + other).freeze()
 
-    def __radd__(self, other) -> 'cirq.FrozenCircuit':
+    def __radd__(self, other) -> cirq.FrozenCircuit:
         return (other + self.unfreeze()).freeze()
 
     # Needed for numpy to handle multiplication by np.int64 correctly.
     __array_priority__ = 10000
 
     # TODO: handle multiplication / powers differently?
-    def __mul__(self, other) -> 'cirq.FrozenCircuit':
+    def __mul__(self, other) -> cirq.FrozenCircuit:
         return (self.unfreeze() * other).freeze()
 
-    def __rmul__(self, other) -> 'cirq.FrozenCircuit':
+    def __rmul__(self, other) -> cirq.FrozenCircuit:
         return (other * self.unfreeze()).freeze()
 
-    def __pow__(self, other) -> 'cirq.FrozenCircuit':
+    def __pow__(self, other) -> cirq.FrozenCircuit:
         try:
             return (self.unfreeze() ** other).freeze()
         except:
@@ -238,20 +242,20 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         return cls(moments, strategy=InsertStrategy.EARLIEST, tags=tags)
 
     def concat_ragged(
-        *circuits: 'cirq.AbstractCircuit', align: Union['cirq.Alignment', str] = Alignment.LEFT
-    ) -> 'cirq.FrozenCircuit':
+        *circuits: cirq.AbstractCircuit, align: Union[cirq.Alignment, str] = Alignment.LEFT
+    ) -> cirq.FrozenCircuit:
         return AbstractCircuit.concat_ragged(*circuits, align=align).freeze()
 
     concat_ragged.__doc__ = AbstractCircuit.concat_ragged.__doc__
 
     def zip(
-        *circuits: 'cirq.AbstractCircuit', align: Union['cirq.Alignment', str] = Alignment.LEFT
-    ) -> 'cirq.FrozenCircuit':
+        *circuits: cirq.AbstractCircuit, align: Union[cirq.Alignment, str] = Alignment.LEFT
+    ) -> cirq.FrozenCircuit:
         return AbstractCircuit.zip(*circuits, align=align).freeze()
 
     zip.__doc__ = AbstractCircuit.zip.__doc__
 
-    def to_op(self) -> 'cirq.CircuitOperation':
+    def to_op(self) -> cirq.CircuitOperation:
         """Creates a CircuitOperation wrapping this circuit."""
         from cirq.circuits import CircuitOperation
 

cirq/circuits/insert_strategy.py

@@ -23,6 +23,16 @@ class InsertStrategy:
     INLINE: 'InsertStrategy'
     EARLIEST: 'InsertStrategy'
 
+    def __new__(cls, name: str, doc: str) -> 'InsertStrategy':
+        inst = getattr(cls, name, None)
+        if not inst or not isinstance(inst, cls):
+            inst = super().__new__(cls)
+        return inst
+
+    def __getnewargs__(self):
+        """Returns a tuple of args to pass to __new__ when unpickling."""
+        return (self.name, self.__doc__)
+
     def __init__(self, name: str, doc: str):
         self.name = name
         self.__doc__ = doc

cirq/circuits/insert_strategy_test.py

@@ -12,8 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import pickle
+
+import pytest
+
 import cirq
 
 
 def test_repr():
     assert repr(cirq.InsertStrategy.NEW) == 'cirq.InsertStrategy.NEW'
+    assert str(cirq.InsertStrategy.NEW) == 'NEW'
+
+
+@pytest.mark.parametrize(
+    'strategy',
+    [
+        cirq.InsertStrategy.NEW,
+        cirq.InsertStrategy.NEW_THEN_INLINE,
+        cirq.InsertStrategy.INLINE,
+        cirq.InsertStrategy.EARLIEST,
+    ],
+    ids=lambda strategy: strategy.name,
+)
+def test_identity_after_pickling(strategy: cirq.InsertStrategy):
+    unpickled_strategy = pickle.loads(pickle.dumps(strategy))
+    assert unpickled_strategy is strategy