cirq-core 1.2.0.dev20230717232332__py3-none-any.whl → 1.3.0__py3-none-any.whl

cirq/__init__.py

@@ -224,6 +224,7 @@ from cirq.ops import (
     givens,
     GlobalPhaseGate,
     global_phase_operation,
+    GreedyQubitManager,
     H,
     HPowGate,
     I,
@@ -301,6 +302,7 @@ from cirq.ops import (
     ry,
     rz,
     S,
+    SimpleQubitManager,
     SingleQubitCliffordGate,
     SingleQubitPauliStringGateOperation,
     SQRT_ISWAP,
@@ -356,6 +358,7 @@ from cirq.transformers import (
     is_negligible_turn,
     LineInitialMapper,
     MappingManager,
+    map_clean_and_borrowable_qubits,
     map_moments,
     map_operations,
     map_operations_and_unroll,
@@ -370,6 +373,7 @@ from cirq.transformers import (
     optimize_for_target_gateset,
     parameterized_2q_op_to_sqrt_iswap_operations,
     prepare_two_qubit_state_using_cz,
+    prepare_two_qubit_state_using_iswap,
     prepare_two_qubit_state_using_sqrt_iswap,
     quantum_shannon_decomposition,
     RouteCQC,
@@ -437,6 +441,7 @@ from cirq.qis import (
 
 from cirq.sim import (
     CIRCUIT_LIKE,
+    ClassicalStateSimulator,
     CliffordSimulator,
     CliffordState,
     CliffordSimulatorStepResult,

cirq/_compat.py

@@ -191,6 +191,9 @@ def proper_repr(value: Any) -> str:
     if isinstance(value, Dict):
         return '{' + ','.join(f"{proper_repr(k)}: {proper_repr(v)}" for k, v in value.items()) + '}'
 
+    if hasattr(value, "__qualname__"):
+        return f"{value.__module__}.{value.__qualname__}"
+
     return repr(value)
 
 
@@ -400,23 +403,36 @@ def deprecated_parameter(
     _validate_deadline(deadline)
 
     def decorator(func: Callable) -> Callable:
+        def deprecation_warning():
+            qualname = func.__qualname__ if func_name is None else func_name
+            _warn_or_error(
+                f'The {parameter_desc} parameter of {qualname} was '
+                f'used but is deprecated.\n'
+                f'It will be removed in cirq {deadline}.\n'
+                f'{fix}\n'
+            )
+
         @functools.wraps(func)
         def decorated_func(*args, **kwargs) -> Any:
             if match(args, kwargs):
                 if rewrite is not None:
                     args, kwargs = rewrite(args, kwargs)
+                deprecation_warning()
+            return func(*args, **kwargs)
 
-                qualname = func.__qualname__ if func_name is None else func_name
-                _warn_or_error(
-                    f'The {parameter_desc} parameter of {qualname} was '
-                    f'used but is deprecated.\n'
-                    f'It will be removed in cirq {deadline}.\n'
-                    f'{fix}\n'
-                )
+        @functools.wraps(func)
+        async def async_decorated_func(*args, **kwargs) -> Any:
+            if match(args, kwargs):
+                if rewrite is not None:
+                    args, kwargs = rewrite(args, kwargs)
+                deprecation_warning()
 
-            return func(*args, **kwargs)
+            return await func(*args, **kwargs)
 
-        return decorated_func
+        if inspect.iscoroutinefunction(func):
+            return async_decorated_func
+        else:
+            return decorated_func
 
     return decorator
 
@@ -436,13 +452,12 @@ def deprecate_attributes(module_name: str, deprecated_attributes: Dict[str, Tupl
         will cause a warning for these deprecated attributes.
     """
 
-    for (deadline, _) in deprecated_attributes.values():
+    for deadline, _ in deprecated_attributes.values():
         _validate_deadline(deadline)
 
     module = sys.modules[module_name]
 
     class Wrapped(ModuleType):
-
         __dict__ = module.__dict__
 
         # Workaround for: https://github.com/python/mypy/issues/8083

cirq/_compat_test.py

@@ -14,6 +14,7 @@
 import collections
 import dataclasses
 import importlib.metadata
+import inspect
 import logging
 import multiprocessing
 import os
@@ -26,7 +27,7 @@ from typing import Any, Callable, Dict, Optional, Tuple
 from importlib.machinery import ModuleSpec
 from unittest import mock
 
-
+import duet
 import numpy as np
 import pandas as pd
 import pytest
@@ -263,6 +264,40 @@ def test_deprecated_parameter():
         # pylint: enable=unused-variable
 
 
+@duet.sync
+async def test_deprecated_parameter_async_function():
+    @deprecated_parameter(
+        deadline='v1.2',
+        fix='Double it yourself.',
+        func_name='test_func',
+        parameter_desc='double_count',
+        match=lambda args, kwargs: 'double_count' in kwargs,
+        rewrite=lambda args, kwargs: (args, {'new_count': kwargs['double_count'] * 2}),
+    )
+    async def f(new_count):
+        return new_count
+
+    assert inspect.iscoroutinefunction(f)
+
+    # Does not warn on usual use.
+    with cirq.testing.assert_logs(count=0):
+        assert await f(1) == 1
+        assert await f(new_count=1) == 1
+
+    with cirq.testing.assert_deprecated(
+        '_compat_test.py:',
+        'double_count parameter of test_func was used',
+        'will be removed in cirq v1.2',
+        'Double it yourself.',
+        deadline='v1.2',
+    ):
+        # pylint: disable=unexpected-keyword-arg
+        # pylint: disable=no-value-for-parameter
+        assert await f(double_count=1) == 2
+        # pylint: enable=no-value-for-parameter
+        # pylint: enable=unexpected-keyword-arg
+
+
 def test_wrap_module():
     my_module = types.ModuleType('my_module', 'my doc string')
     my_module.foo = 'foo'
@@ -781,8 +816,7 @@ def test_deprecated_module_deadline_validation():
 
 def _test_broken_module_1_inner():
     with pytest.raises(
-        DeprecatedModuleImportError,
-        match="missing_module cannot be imported. " "The typical reasons",
+        DeprecatedModuleImportError, match="missing_module cannot be imported. The typical reasons"
     ):
         # pylint: disable=unused-import
         import cirq.testing._compat_test_data.broken_ref as br  # type: ignore

cirq/_version.py

@@ -1 +1,31 @@
-__version__ = "1.2.0.dev20230717232332"
+# Copyright 2018 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Define version number here, read it from setup.py automatically,
+and warn users that the latest version of cirq uses python 3.9+"""
+
+import sys
+
+if sys.version_info < (3, 9, 0):  # pragma: no cover
+    raise SystemError(
+        "You installed the latest version of cirq but aren't on python 3.9+.\n"
+        'To fix this error, you need to either:\n'
+        '\n'
+        'A) Update to python 3.9 or later.\n'
+        '- OR -\n'
+        'B) Explicitly install an older deprecated-but-compatible version '
+        'of cirq (e.g. "python -m pip install cirq==1.1.*")'
+    )
+
+__version__ = "1.3.0"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.2.0.dev"
+    assert cirq.__version__ == "1.3.0.dev"

cirq/circuits/circuit.py

@@ -149,11 +149,26 @@ class AbstractCircuit(abc.ABC):
         """Create a circuit from moment op trees.
 
         Args:
-            *moments: Op tree for each moment.
+            *moments: Op tree for each moment. If an op tree is a moment, it
+                will be included directly in the new circuit. If an op tree is
+                a circuit, it will be frozen, wrapped in a CircuitOperation, and
+                included in its own moment in the new circuit. Otherwise, the
+                op tree will be passed to `cirq.Moment` to create a new moment
+                which is then included in the new circuit. Note that in the
+                latter case we have the normal restriction that operations in a
+                moment must be applied to disjoint sets of qubits.
         """
-        return cls._from_moments(
-            moment if isinstance(moment, Moment) else Moment(moment) for moment in moments
-        )
+        return cls._from_moments(cls._make_moments(moments))
+
+    @staticmethod
+    def _make_moments(moments: Iterable['cirq.OP_TREE']) -> Iterator['cirq.Moment']:
+        for m in moments:
+            if isinstance(m, Moment):
+                yield m
+            elif isinstance(m, AbstractCircuit):
+                yield Moment(m.freeze().to_op())
+            else:
+                yield Moment(m)
 
     @classmethod
     @abc.abstractmethod
@@ -173,28 +188,20 @@ class AbstractCircuit(abc.ABC):
     def moments(self) -> Sequence['cirq.Moment']:
         pass
 
+    @abc.abstractmethod
     def freeze(self) -> 'cirq.FrozenCircuit':
         """Creates a FrozenCircuit from this circuit.
 
         If 'self' is a FrozenCircuit, the original object is returned.
         """
-        from cirq.circuits import FrozenCircuit
-
-        if isinstance(self, FrozenCircuit):
-            return self
-
-        return FrozenCircuit(self, strategy=InsertStrategy.EARLIEST)
 
+    @abc.abstractmethod
     def unfreeze(self, copy: bool = True) -> 'cirq.Circuit':
         """Creates a Circuit from this circuit.
 
         Args:
             copy: If True and 'self' is a Circuit, returns a copy that circuit.
         """
-        if isinstance(self, Circuit):
-            return Circuit.copy(self) if copy else self
-
-        return Circuit(self, strategy=InsertStrategy.EARLIEST)
 
     def __bool__(self):
         return bool(self.moments)
@@ -272,12 +279,15 @@ class AbstractCircuit(abc.ABC):
     def __str__(self) -> str:
         return self.to_text_diagram()
 
-    def __repr__(self) -> str:
-        cls_name = self.__class__.__name__
+    def _repr_args(self) -> str:
         args = []
         if self.moments:
             args.append(_list_repr_with_indented_item_lines(self.moments))
-        return f'cirq.{cls_name}({", ".join(args)})'
+        return f'{", ".join(args)}'
+
+    def __repr__(self) -> str:
+        cls_name = self.__class__.__name__
+        return f'cirq.{cls_name}({self._repr_args()})'
 
     def _repr_pretty_(self, p: Any, cycle: bool) -> None:
         """Print ASCII diagram in Jupyter."""
@@ -804,6 +814,9 @@ class AbstractCircuit(abc.ABC):
         """
         return protocols.is_measurement(self)
 
+    def _is_measurement_(self) -> bool:
+        return any(protocols.is_measurement(op) for op in self.all_operations())
+
     def are_all_measurements_terminal(self) -> bool:
         """Whether all measurement gates are at the end of the circuit.
 
@@ -1365,8 +1378,7 @@ class AbstractCircuit(abc.ABC):
         self._to_qasm_output(header, precision, qubit_order).save(file_path)
 
     def _json_dict_(self):
-        ret = protocols.obj_to_dict_helper(self, ['moments'])
-        return ret
+        return protocols.obj_to_dict_helper(self, ['moments'])
 
     @classmethod
     def _from_json_dict_(cls, moments, **kwargs):
@@ -1462,14 +1474,14 @@ class AbstractCircuit(abc.ABC):
 
         Beware that this method is *not* associative. For example:
 
-            >>> a, b = cirq.LineQubit.range(2)
-            >>> A = cirq.Circuit(cirq.H(a))
-            >>> B = cirq.Circuit(cirq.H(b))
-            >>> f = cirq.Circuit.concat_ragged
-            >>> f(f(A, B), A) == f(A, f(B, A))
-            False
-            >>> len(f(f(f(A, B), A), B)) == len(f(f(A, f(B, A)), B))
-            False
+        >>> a, b = cirq.LineQubit.range(2)
+        >>> A = cirq.Circuit(cirq.H(a))
+        >>> B = cirq.Circuit(cirq.H(b))
+        >>> f = cirq.Circuit.concat_ragged
+        >>> f(f(A, B), A) == f(A, f(B, A))
+        False
+        >>> len(f(f(f(A, B), A), B)) == len(f(f(A, f(B, A)), B))
+        False
 
         Args:
             *circuits: The circuits to concatenate.
@@ -1741,6 +1753,16 @@ class Circuit(AbstractCircuit):
                 circuit.
         """
         self._moments: List['cirq.Moment'] = []
+
+        # Implementation note: the following cached properties are set lazily and then
+        # invalidated and reset to None in `self._mutated()`, which is called any time
+        # `self._moments` is changed.
+        self._all_qubits: Optional[FrozenSet['cirq.Qid']] = None
+        self._frozen: Optional['cirq.FrozenCircuit'] = None
+        self._is_measurement: Optional[bool] = None
+        self._is_parameterized: Optional[bool] = None
+        self._parameter_names: Optional[AbstractSet[str]] = None
+
         flattened_contents = tuple(ops.flatten_to_ops_or_moments(contents))
         if all(isinstance(c, Moment) for c in flattened_contents):
             self._moments[:] = cast(Iterable[Moment], flattened_contents)
@@ -1751,6 +1773,14 @@ class Circuit(AbstractCircuit):
             else:
                 self.append(flattened_contents, strategy=strategy)
 
+    def _mutated(self) -> None:
+        """Clear cached properties in response to this circuit being mutated."""
+        self._all_qubits = None
+        self._frozen = None
+        self._is_measurement = None
+        self._is_parameterized = None
+        self._parameter_names = None
+
     @classmethod
     def _from_moments(cls, moments: Iterable['cirq.Moment']) -> 'Circuit':
         new_circuit = Circuit()
@@ -1791,7 +1821,6 @@ class Circuit(AbstractCircuit):
 
         # "mop" means current moment-or-operation
         for mop in ops.flatten_to_ops_or_moments(contents):
-
             # Identify the index of the moment to place this `mop` into.
             placement_index = get_earliest_accommodating_moment_index(
                 mop, qubit_indices, mkey_indices, ckey_indices, length
@@ -1814,6 +1843,41 @@ class Circuit(AbstractCircuit):
     def __copy__(self) -> 'cirq.Circuit':
         return self.copy()
 
+    def freeze(self) -> 'cirq.FrozenCircuit':
+        """Gets a frozen version of this circuit.
+
+        Repeated calls to `.freeze()` will return the same FrozenCircuit
+        instance as long as this circuit is not mutated.
+        """
+        from cirq.circuits.frozen_circuit import FrozenCircuit
+
+        if self._frozen is None:
+            self._frozen = FrozenCircuit.from_moments(*self._moments)
+        return self._frozen
+
+    def unfreeze(self, copy: bool = True) -> 'cirq.Circuit':
+        return self.copy() if copy else self
+
+    def all_qubits(self) -> FrozenSet['cirq.Qid']:
+        if self._all_qubits is None:
+            self._all_qubits = super().all_qubits()
+        return self._all_qubits
+
+    def _is_measurement_(self) -> bool:
+        if self._is_measurement is None:
+            self._is_measurement = super()._is_measurement_()
+        return self._is_measurement
+
+    def _is_parameterized_(self) -> bool:
+        if self._is_parameterized is None:
+            self._is_parameterized = super()._is_parameterized_()
+        return self._is_parameterized
+
+    def _parameter_names_(self) -> AbstractSet[str]:
+        if self._parameter_names is None:
+            self._parameter_names = super()._parameter_names_()
+        return self._parameter_names
+
     def copy(self) -> 'Circuit':
         """Return a copy of this circuit."""
         copied_circuit = Circuit()
@@ -1839,11 +1903,13 @@ class Circuit(AbstractCircuit):
                 raise TypeError('Can only assign Moments into Circuits.')
 
         self._moments[key] = value
+        self._mutated()
 
     # pylint: enable=function-redefined
 
     def __delitem__(self, key: Union[int, slice]):
         del self._moments[key]
+        self._mutated()
 
     def __iadd__(self, other):
         self.append(other)
@@ -1872,6 +1938,7 @@ class Circuit(AbstractCircuit):
         if not isinstance(repetitions, (int, np.integer)):
             return NotImplemented
         self._moments *= int(repetitions)
+        self._mutated()
         return self
 
     def __mul__(self, repetitions: _INT_TYPE):
@@ -2015,6 +2082,7 @@ class Circuit(AbstractCircuit):
 
         if strategy is InsertStrategy.NEW or strategy is InsertStrategy.NEW_THEN_INLINE:
             self._moments.insert(splitter_index, Moment())
+            self._mutated()
             return splitter_index
 
         if strategy is InsertStrategy.INLINE:
@@ -2082,6 +2150,7 @@ class Circuit(AbstractCircuit):
                 k = max(k, p + 1)
                 if strategy is InsertStrategy.NEW_THEN_INLINE:
                     strategy = InsertStrategy.INLINE
+        self._mutated()
         return k
 
     def insert_into_range(self, operations: 'cirq.OP_TREE', start: int, end: int) -> int:
@@ -2118,6 +2187,7 @@ class Circuit(AbstractCircuit):
 
             self._moments[i] = self._moments[i].with_operation(op)
             op_index += 1
+        self._mutated()
 
         if op_index >= len(flat_ops):
             return end
@@ -2163,6 +2233,7 @@ class Circuit(AbstractCircuit):
         if n_new_moments > 0:
             insert_index = min(late_frontier.values())
             self._moments[insert_index:insert_index] = [Moment()] * n_new_moments
+            self._mutated()
             for q in update_qubits:
                 if early_frontier.get(q, 0) > insert_index:
                     early_frontier[q] += n_new_moments
@@ -2189,13 +2260,12 @@ class Circuit(AbstractCircuit):
         if len(operations) != len(insertion_indices):
             raise ValueError('operations and insertion_indices must have the same length.')
         self._moments += [Moment() for _ in range(1 + max(insertion_indices) - len(self))]
+        self._mutated()
         moment_to_ops: Dict[int, List['cirq.Operation']] = defaultdict(list)
         for op_index, moment_index in enumerate(insertion_indices):
             moment_to_ops[moment_index].append(operations[op_index])
         for moment_index, new_ops in moment_to_ops.items():
-            self._moments[moment_index] = Moment(
-                self._moments[moment_index].operations + tuple(new_ops)
-            )
+            self._moments[moment_index] = self._moments[moment_index].with_operations(*new_ops)
 
     def insert_at_frontier(
         self,
@@ -2257,6 +2327,7 @@ class Circuit(AbstractCircuit):
                 old_op for old_op in copy._moments[i].operations if op != old_op
             )
         self._moments = copy._moments
+        self._mutated()
 
     def batch_replace(
         self, replacements: Iterable[Tuple[int, 'cirq.Operation', 'cirq.Operation']]
@@ -2281,6 +2352,7 @@ class Circuit(AbstractCircuit):
                 old_op if old_op != op else new_op for old_op in copy._moments[i].operations
             )
         self._moments = copy._moments
+        self._mutated()
 
     def batch_insert_into(self, insert_intos: Iterable[Tuple[int, 'cirq.OP_TREE']]) -> None:
         """Inserts operations into empty spaces in existing moments.
@@ -2301,6 +2373,7 @@ class Circuit(AbstractCircuit):
         for i, insertions in insert_intos:
             copy._moments[i] = copy._moments[i].with_operations(insertions)
         self._moments = copy._moments
+        self._mutated()
 
     def batch_insert(self, insertions: Iterable[Tuple[int, 'cirq.OP_TREE']]) -> None:
         """Applies a batched insert operation to the circuit.
@@ -2335,6 +2408,7 @@ class Circuit(AbstractCircuit):
             if next_index > insert_index:
                 shift += next_index - insert_index
         self._moments = copy._moments
+        self._mutated()
 
     def append(
         self,
@@ -2365,6 +2439,7 @@ class Circuit(AbstractCircuit):
         for k in moment_indices:
             if 0 <= k < len(self._moments):
                 self._moments[k] = self._moments[k].without_operations_touching(qubits)
+        self._mutated()
 
     @property
     def moments(self) -> Sequence['cirq.Moment']:
@@ -2450,7 +2525,6 @@ def _draw_moment_annotations(
     first_annotation_row: int,
     transpose: bool,
 ):
-
     for k, annotation in enumerate(_get_moment_annotations(moment)):
         args = protocols.CircuitDiagramInfoArgs(
             known_qubits=(),

cirq/circuits/circuit_operation.py

@@ -61,9 +61,9 @@ def _full_join_string_lists(
     list1: Optional[Sequence[str]], list2: Optional[Sequence[str]]
 ) -> Optional[Sequence[str]]:
     if list1 is None and list2 is None:
-        return None  # coverage: ignore
+        return None  # pragma: no cover
     if list1 is None:
-        return list2  # coverage: ignore
+        return list2  # pragma: no cover
     if list2 is None:
         return list1
     return [f'{first}{REPETITION_ID_SEPARATOR}{second}' for first in list1 for second in list2]

cirq/circuits/circuit_operation_test.py

@@ -351,7 +351,7 @@ def test_repeat_zero_times(add_measurements, use_repetition_ids, initial_reps):
 
 
 def test_no_repetition_ids():
-    def default_repetition_ids(self):
+    def default_repetition_ids(self):  # pragma: no cover
         assert False, "Should not call default_repetition_ids"
 
     with mock.patch.object(circuit_operation, 'default_repetition_ids', new=default_repetition_ids):