Merge branch 'master' into core-np1.24

Author: pavoljuhas

.github/workflows/ci.yml

@@ -336,6 +336,7 @@ jobs:
     runs-on: ubuntu-20.04
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
         with:
           node-version: '14.16.1'
       - name: Install npm
@@ -347,6 +348,7 @@ jobs:
     runs-on: ubuntu-20.04
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
         with:
           node-version: '14.16.1'
       - name: Install npm
@@ -358,6 +360,7 @@ jobs:
     runs-on: ubuntu-20.04
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
         with:
           node-version: '14.16.1'
       - name: Install npm dependencies
@@ -371,6 +374,7 @@ jobs:
     runs-on: ubuntu-20.04
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
         with:
           node-version: '14.16.1'
       - name: Install npm dependencies

asv.conf.json

@@ -9,6 +9,7 @@
     "environment_type": "virtualenv",
     "show_commit_url": "https://github.com/quantumlib/Cirq/commit/",
     "pythons": ["3.8"],
+    "matrix": {"env_nobuild": {"PYTHONOPTIMIZE": ["-O", ""]}},
     "benchmark_dir": "benchmarks",
     "env_dir": ".asv/env",
     "results_dir": ".asv/results",

cirq-core/cirq/__init__.py

@@ -16,6 +16,8 @@
 
 from cirq import _import
 
+from cirq._compat import __cirq_debug__, with_debug
+
 # A module can only depend on modules imported earlier in this list of modules
 # at import time.  Pytest will fail otherwise (enforced by
 # dev_tools/import_test.py).
@@ -236,6 +238,7 @@
     LinearCombinationOfOperations,
     MatrixGate,
     MixedUnitaryChannel,
+    M,
     measure,
     measure_each,
     measure_paulistring_terms,
@@ -284,6 +287,7 @@
     QubitOrder,
     QubitOrderOrList,
     QubitPermutationGate,
+    R,
     reset,
     reset_each,
     ResetChannel,

cirq-core/cirq/_compat.py

@@ -14,6 +14,7 @@
 
 """Workarounds for compatibility issues between versions and libraries."""
 import contextlib
+import contextvars
 import dataclasses
 import functools
 import importlib
@@ -24,15 +25,41 @@
 import traceback
 import warnings
 from types import ModuleType
-from typing import Any, Callable, Dict, Optional, overload, Set, Tuple, Type, TypeVar
+from typing import Any, Callable, Dict, Iterator, Optional, overload, Set, Tuple, Type, TypeVar
 
 import numpy as np
 import pandas as pd
 import sympy
 import sympy.printing.repr
 
+from cirq._doc import document
+
 ALLOW_DEPRECATION_IN_TEST = 'ALLOW_DEPRECATION_IN_TEST'
 
+__cirq_debug__ = contextvars.ContextVar('__cirq_debug__', default=__debug__)
+document(
+    __cirq_debug__,
+    "A cirq specific flag which can be used to conditionally turn off all validations across Cirq "
+    "to boost performance in production mode. Defaults to python's built-in constant __debug__. "
+    "The flag is implemented as a `ContextVar` and is thread safe.",
+)
+
+
+@contextlib.contextmanager
+def with_debug(value: bool) -> Iterator[None]:
+    """Sets the value of global constant `cirq.__cirq_debug__` within the context.
+
+    If `__cirq_debug__` is set to False, all validations in Cirq are disabled to optimize
+    performance. Users should use the `cirq.with_debug` context manager instead of manually
+    mutating the value of `__cirq_debug__` flag. On exit, the context manager resets the
+    value of `__cirq_debug__` flag to what it was before entering the context manager.
+    """
+    token = __cirq_debug__.set(value)
+    try:
+        yield
+    finally:
+        __cirq_debug__.reset(token)
+
 
 try:
     from functools import cached_property  # pylint: disable=unused-import

cirq-core/cirq/_compat_test.py

@@ -51,6 +51,16 @@
 )
 
 
+def test_with_debug():
+    assert cirq.__cirq_debug__.get()
+    with cirq.with_debug(False):
+        assert not cirq.__cirq_debug__.get()
+        with cirq.with_debug(True):
+            assert cirq.__cirq_debug__.get()
+        assert not cirq.__cirq_debug__.get()
+    assert cirq.__cirq_debug__.get()
+
+
 def test_proper_repr():
     v = sympy.Symbol('t') * 3
     v2 = eval(proper_repr(v))

cirq-core/cirq/circuits/circuit.py

@@ -1861,9 +1861,8 @@ def __setitem__(self, key: slice, value: Iterable['cirq.Moment']):
         pass
 
     def __setitem__(self, key, value):
-        if isinstance(key, int):
-            if not isinstance(value, Moment):
-                raise TypeError('Can only assign Moments into Circuits.')
+        if isinstance(key, int) and not isinstance(value, Moment):
+            raise TypeError('Can only assign Moments into Circuits.')
 
         if isinstance(key, slice):
             value = list(value)
@@ -2595,8 +2594,7 @@ def _get_global_phase_and_tags_for_op(op: 'cirq.Operation') -> Tuple[Optional[co
     elif isinstance(op.untagged, CircuitOperation):
         op_phase, op_tags = _get_global_phase_and_tags_for_ops(op.untagged.circuit.all_operations())
         return op_phase, list(op.tags) + op_tags
-    else:
-        return None, []
+    return None, []
 
 
 def _get_global_phase_and_tags_for_ops(op_list: Any) -> Tuple[Optional[complex], List[Any]]:

cirq-core/cirq/circuits/frozen_circuit.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """An immutable version of the Circuit data structure."""
-from typing import FrozenSet, Iterable, Iterator, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import AbstractSet, FrozenSet, Iterable, Iterator, Sequence, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
 
@@ -83,6 +83,10 @@ def _num_qubits_(self) -> int:
     def _qid_shape_(self) -> Tuple[int, ...]:
         return super()._qid_shape_()
 
+    @_compat.cached_method
+    def _has_unitary_(self) -> bool:
+        return super()._has_unitary_()
+
     @_compat.cached_method
     def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
         return super()._unitary_()
@@ -124,6 +128,14 @@ def are_all_measurements_terminal(self) -> bool:
     def all_measurement_key_names(self) -> FrozenSet[str]:
         return frozenset(str(key) for key in self.all_measurement_key_objs())
 
+    @_compat.cached_method
+    def _is_parameterized_(self) -> bool:
+        return super()._is_parameterized_()
+
+    @_compat.cached_method
+    def _parameter_names_(self) -> AbstractSet[str]:
+        return super()._parameter_names_()
+
     def _measurement_key_names_(self) -> FrozenSet[str]:
         return self.all_measurement_key_names()
 

cirq-core/cirq/circuits/moment.py

@@ -36,7 +36,7 @@
 
 import numpy as np
 
-from cirq import protocols, ops, qis
+from cirq import protocols, ops, qis, _compat
 from cirq._import import LazyLoader
 from cirq.ops import raw_types, op_tree
 from cirq.protocols import circuit_diagram_info_protocol
@@ -148,8 +148,7 @@ def operation_at(self, qubit: raw_types.Qid) -> Optional['cirq.Operation']:
         """
         if self.operates_on([qubit]):
             return self.__getitem__(qubit)
-        else:
-            return None
+        return None
 
     def with_operation(self, operation: 'cirq.Operation') -> 'cirq.Moment':
         """Returns an equal moment, but with the given op added.
@@ -238,9 +237,11 @@ def without_operations_touching(self, qubits: Iterable['cirq.Qid']) -> 'cirq.Mom
             if qubits.isdisjoint(frozenset(operation.qubits))
         )
 
+    @_compat.cached_method()
     def _is_parameterized_(self) -> bool:
         return any(protocols.is_parameterized(op) for op in self)
 
+    @_compat.cached_method()
     def _parameter_names_(self) -> AbstractSet[str]:
         return {name for op in self for name in protocols.parameter_names(op)}
 
@@ -266,6 +267,7 @@ def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]):
             for op in self.operations
         )
 
+    @_compat.cached_method()
     def _measurement_key_names_(self) -> FrozenSet[str]:
         return frozenset(str(key) for key in self._measurement_key_objs_())
 
@@ -333,6 +335,7 @@ def _approx_eq_(self, other: Any, atol: Union[int, float]) -> bool:
     def __ne__(self, other) -> bool:
         return not self == other
 
+    @_compat.cached_method()
     def __hash__(self):
         return hash((Moment, self._sorted_operations_()))
 
@@ -406,6 +409,7 @@ def expand_to(self, qubits: Iterable['cirq.Qid']) -> 'cirq.Moment':
             operations.append(ops.I(q))
         return Moment(*operations)
 
+    @_compat.cached_method()
     def _has_kraus_(self) -> bool:
         """Returns True if self has a Kraus representation and self uses <= 10 qubits."""
         return all(protocols.has_kraus(op) for op in self.operations) and len(self.qubits) <= 10

cirq-core/cirq/ops/__init__.py

@@ -41,6 +41,7 @@
     phase_flip,
     PhaseDampingChannel,
     PhaseFlipChannel,
+    R,
     reset,
     reset_each,
     ResetChannel,
@@ -126,6 +127,7 @@
 from cirq.ops.matrix_gates import MatrixGate
 
 from cirq.ops.measure_util import (
+    M,
     measure,
     measure_each,
     measure_paulistring_terms,

cirq-core/cirq/ops/common_channels.py

@@ -775,10 +775,16 @@ def _json_dict_(self) -> Dict[str, Any]:
 
 
 def reset(qubit: 'cirq.Qid') -> raw_types.Operation:
-    """Returns a `cirq.ResetChannel` on the given qubit."""
+    """Returns a `cirq.ResetChannel` on the given qubit.
+
+    This can also be used with the alias `cirq.R`.
+    """
     return ResetChannel(qubit.dimension).on(qubit)
 
 
+R = reset
+
+
 def reset_each(*qubits: 'cirq.Qid') -> List[raw_types.Operation]:
     """Returns a list of `cirq.ResetChannel` instances on the given qubits."""
     return [ResetChannel(q.dimension).on(q) for q in qubits]

cirq-core/cirq/ops/common_gates.py

@@ -120,6 +120,10 @@ def __init__(
         super().__init__(exponent=exponent, global_shift=global_shift)
         self._dimension = dimension
 
+    @property
+    def dimension(self) -> value.TParamVal:
+        return self._dimension
+
     def _num_qubits_(self) -> int:
         return 1
 
@@ -316,6 +320,18 @@ def __repr__(self) -> str:
         all_args = ', '.join(args)
         return f'cirq.XPowGate({all_args})'
 
+    def _json_dict_(self) -> Dict[str, Any]:
+        d = protocols.obj_to_dict_helper(self, ['exponent', 'global_shift'])
+        if self.dimension != 2:
+            d['dimension'] = self.dimension
+        return d
+
+    def _value_equality_values_(self):
+        return (*super()._value_equality_values_(), self._dimension)
+
+    def _value_equality_approximate_values_(self):
+        return (*super()._value_equality_approximate_values_(), self._dimension)
+
 
 class Rx(XPowGate):
     r"""A gate with matrix $e^{-i X t/2}$ that rotates around the X axis of the Bloch sphere by $t$.
@@ -608,6 +624,10 @@ def __init__(
         super().__init__(exponent=exponent, global_shift=global_shift)
         self._dimension = dimension
 
+    @property
+    def dimension(self) -> value.TParamVal:
+        return self._dimension
+
     def _num_qubits_(self) -> int:
         return 1
 
@@ -834,6 +854,18 @@ def _commutes_on_qids_(
             return NotImplemented
         return True
 
+    def _json_dict_(self) -> Dict[str, Any]:
+        d = protocols.obj_to_dict_helper(self, ['exponent', 'global_shift'])
+        if self.dimension != 2:
+            d['dimension'] = self.dimension
+        return d
+
+    def _value_equality_values_(self):
+        return (*super()._value_equality_values_(), self._dimension)
+
+    def _value_equality_approximate_values_(self):
+        return (*super()._value_equality_approximate_values_(), self._dimension)
+
 
 class Rz(ZPowGate):
     r"""A gate with matrix $e^{-i Z t/2}$ that rotates around the Z axis of the Bloch sphere by $t$.

cirq-core/cirq/ops/common_gates_test.py

@@ -1100,6 +1100,7 @@ def test_approx_eq():
 
 def test_xpow_dim_3():
     x = cirq.XPowGate(dimension=3)
+    assert cirq.X != x
     # fmt: off
     expected = [
         [0, 0, 1],
@@ -1127,6 +1128,7 @@ def test_xpow_dim_3():
 
 def test_xpow_dim_4():
     x = cirq.XPowGate(dimension=4)
+    assert cirq.X != x
     # fmt: off
     expected = [
         [0, 0, 0, 1],
@@ -1159,6 +1161,7 @@ def test_zpow_dim_3():
     L = np.exp(2 * np.pi * 1j / 3)
     L2 = L**2
     z = cirq.ZPowGate(dimension=3)
+    assert cirq.Z != z
     # fmt: off
     expected = [
         [1, 0, 0],
@@ -1209,6 +1212,7 @@ def test_zpow_dim_3():
 
 def test_zpow_dim_4():
     z = cirq.ZPowGate(dimension=4)
+    assert cirq.Z != z
     # fmt: off
     expected = [
         [1, 0, 0, 0],

cirq-core/cirq/ops/matrix_gates.py

@@ -114,11 +114,15 @@ def with_name(self, name: str) -> 'MatrixGate':
         return MatrixGate(self._matrix, name=name, qid_shape=self._qid_shape, unitary_check=False)
 
     def _json_dict_(self) -> Dict[str, Any]:
-        return {'matrix': self._matrix.tolist(), 'qid_shape': self._qid_shape}
+        return {
+            'matrix': self._matrix.tolist(),
+            'qid_shape': self._qid_shape,
+            **({'name': self._name} if self._name is not None else {}),
+        }
 
     @classmethod
-    def _from_json_dict_(cls, matrix, qid_shape, **kwargs):
-        return cls(matrix=np.array(matrix), qid_shape=qid_shape)
+    def _from_json_dict_(cls, matrix, qid_shape, name=None, **kwargs):
+        return cls(matrix=np.array(matrix), qid_shape=qid_shape, name=name)
 
     def _qid_shape_(self) -> Tuple[int, ...]:
         return self._qid_shape