Merge branch 'master' into stream-client/fake-quantum-run-stream-timing-support

Author: verult

Diff for: cirq-core/cirq/circuits/circuit.py

@@ -272,12 +272,15 @@ def __getitem__(self, key):
     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."""
@@ -1791,7 +1794,6 @@ def _load_contents_with_earliest_strategy(self, contents: 'cirq.OP_TREE'):
 
         # "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
@@ -2450,7 +2452,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=(),

Diff for: cirq-core/cirq/circuits/frozen_circuit.py

@@ -12,7 +12,17 @@
 # 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 AbstractSet, FrozenSet, Iterable, Iterator, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import (
+    AbstractSet,
+    FrozenSet,
+    Hashable,
+    Iterable,
+    Iterator,
+    Sequence,
+    Tuple,
+    TYPE_CHECKING,
+    Union,
+)
 
 import numpy as np
 
@@ -34,7 +44,10 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
     """
 
     def __init__(
-        self, *contents: 'cirq.OP_TREE', strategy: 'cirq.InsertStrategy' = InsertStrategy.EARLIEST
+        self,
+        *contents: 'cirq.OP_TREE',
+        strategy: 'cirq.InsertStrategy' = InsertStrategy.EARLIEST,
+        tags: Sequence[Hashable] = (),
     ) -> None:
         """Initializes a frozen circuit.
 
@@ -47,9 +60,14 @@ def __init__(
             strategy: When initializing the circuit with operations and moments
                 from `contents`, this determines how the operations are packed
                 together.
+            tags: A sequence of any type of object that is useful to attach metadata
+                to this circuit as long as the type is hashable.  If you wish the
+                resulting circuit to be eventually serialized into JSON, you should
+                also restrict the tags to be JSON serializable.
         """
         base = Circuit(contents, strategy=strategy)
         self._moments = tuple(base.moments)
+        self._tags = tuple(tags)
 
     @classmethod
     def _from_moments(cls, moments: Iterable['cirq.Moment']) -> 'FrozenCircuit':
@@ -61,10 +79,35 @@ def _from_moments(cls, moments: Iterable['cirq.Moment']) -> 'FrozenCircuit':
     def moments(self) -> Sequence['cirq.Moment']:
         return self._moments
 
+    @property
+    def tags(self) -> Tuple[Hashable, ...]:
+        """Returns a tuple of the Circuit's tags."""
+        return self._tags
+
+    @_compat.cached_property
+    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':
+        """Creates a new tagged `FrozenCircuit` with `self.tags` and `new_tags` combined."""
+        if not new_tags:
+            return self
+        new_circuit = FrozenCircuit(tags=self.tags + new_tags)
+        new_circuit._moments = self._moments
+        return new_circuit
+
     @_compat.cached_method
     def __hash__(self) -> int:
         # Explicitly cached for performance
-        return hash((self.moments,))
+        return hash((self.moments, self.tags))
+
+    def __eq__(self, other):
+        super_eq = super().__eq__(other)
+        if super_eq is not True:
+            return super_eq
+        other_tags = other.tags if isinstance(other, FrozenCircuit) else ()
+        return self.tags == other_tags
 
     def __getstate__(self):
         # Don't save hash when pickling; see #3777.
@@ -130,11 +173,23 @@ def all_measurement_key_names(self) -> FrozenSet[str]:
 
     @_compat.cached_method
     def _is_parameterized_(self) -> bool:
-        return super()._is_parameterized_()
+        return super()._is_parameterized_() or any(
+            protocols.is_parameterized(tag) for tag in self.tags
+        )
 
     @_compat.cached_method
     def _parameter_names_(self) -> AbstractSet[str]:
-        return super()._parameter_names_()
+        tag_params = {name for tag in self.tags for name in protocols.parameter_names(tag)}
+        return super()._parameter_names_() | tag_params
+
+    def _resolve_parameters_(
+        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
+        ]
+        return resolved_circuit.with_tags(*resolved_tags)
 
     def _measurement_key_names_(self) -> FrozenSet[str]:
         return self.all_measurement_key_names()
@@ -161,6 +216,20 @@ def __pow__(self, other) -> 'cirq.FrozenCircuit':
         except:
             return NotImplemented
 
+    def _repr_args(self) -> str:
+        moments_repr = super()._repr_args()
+        tag_repr = ','.join(_compat.proper_repr(t) for t in self._tags)
+        return f'{moments_repr}, tags=[{tag_repr}]' if self.tags else moments_repr
+
+    def _json_dict_(self):
+        attribute_names = ['moments', 'tags'] if self.tags else ['moments']
+        ret = protocols.obj_to_dict_helper(self, attribute_names)
+        return ret
+
+    @classmethod
+    def _from_json_dict_(cls, moments, *, tags=(), **kwargs):
+        return cls(moments, strategy=InsertStrategy.EARLIEST, tags=tags)
+
     def concat_ragged(
         *circuits: 'cirq.AbstractCircuit', align: Union['cirq.Alignment', str] = Alignment.LEFT
     ) -> 'cirq.FrozenCircuit':

Diff for: cirq-core/cirq/circuits/frozen_circuit_test.py

@@ -17,6 +17,7 @@
 """
 
 import pytest
+import sympy
 
 import cirq
 
@@ -74,3 +75,34 @@ def test_immutable():
         match="(can't set attribute)|(property 'moments' of 'FrozenCircuit' object has no setter)",
     ):
         c.moments = (cirq.Moment(cirq.H(q)), cirq.Moment(cirq.X(q)))
+
+
+def test_tagged_circuits():
+    q = cirq.LineQubit(0)
+    ops = [cirq.X(q), cirq.H(q)]
+    tags = [sympy.Symbol("a"), "b"]
+    circuit = cirq.Circuit(ops)
+    frozen_circuit = cirq.FrozenCircuit(ops)
+    tagged_circuit = cirq.FrozenCircuit(ops, tags=tags)
+    # Test equality
+    assert tagged_circuit.tags == tuple(tags)
+    assert circuit == frozen_circuit != tagged_circuit
+    assert cirq.approx_eq(circuit, frozen_circuit)
+    assert cirq.approx_eq(frozen_circuit, tagged_circuit)
+    # Test hash
+    assert hash(frozen_circuit) != hash(tagged_circuit)
+    # Test _repr_ and _json_ round trips.
+    cirq.testing.assert_equivalent_repr(tagged_circuit)
+    cirq.testing.assert_json_roundtrip_works(tagged_circuit)
+    # Test utility methods and constructors
+    assert frozen_circuit.with_tags() is frozen_circuit
+    assert frozen_circuit.with_tags(*tags) == tagged_circuit
+    assert tagged_circuit.with_tags("c") == cirq.FrozenCircuit(ops, tags=[*tags, "c"])
+    assert tagged_circuit.untagged == frozen_circuit
+    assert frozen_circuit.untagged is frozen_circuit
+    # Test parameterized protocols
+    assert cirq.is_parameterized(frozen_circuit) is False
+    assert cirq.is_parameterized(tagged_circuit) is True
+    assert cirq.parameter_names(tagged_circuit) == {"a"}
+    # Tags are not propagated to diagrams yet.
+    assert str(frozen_circuit) == str(tagged_circuit)

Diff for: cirq-core/cirq/experiments/random_quantum_circuit_generation.py

@@ -693,5 +693,5 @@ def _two_qubit_layer(
     prng: 'np.random.RandomState',
 ) -> 'cirq.OP_TREE':
     for a, b in coupled_qubit_pairs:
-        if (a, b) in layer:
+        if (a, b) in layer or (b, a) in layer:
             yield two_qubit_op_factory(a, b, prng)

Diff for: cirq-core/cirq/experiments/random_quantum_circuit_generation_test.py

@@ -259,6 +259,30 @@ def __init__(self):
     'seed, expected_circuit_length, single_qubit_layers_slice, '
     'two_qubit_layers_slice',
     (
+        (
+            (cirq.q(0, 0), cirq.q(0, 1), cirq.q(0, 2)),
+            4,
+            lambda a, b, _: cirq.CZ(a, b),
+            [[(cirq.q(0, 0), cirq.q(0, 1))], [(cirq.q(0, 1), cirq.q(0, 2))]],
+            (cirq.X**0.5,),
+            True,
+            1234,
+            9,
+            slice(None, None, 2),
+            slice(1, None, 2),
+        ),
+        (
+            (cirq.q(0, 0), cirq.q(0, 1), cirq.q(0, 2)),
+            4,
+            lambda a, b, _: cirq.CZ(a, b),
+            [[(cirq.q(0, 1), cirq.q(0, 0))], [(cirq.q(0, 1), cirq.q(0, 2))]],
+            (cirq.X**0.5,),
+            True,
+            1234,
+            9,
+            slice(None, None, 2),
+            slice(1, None, 2),
+        ),
         (
             cirq.GridQubit.rect(4, 3),
             20,
@@ -406,7 +430,10 @@ def _validate_two_qubit_layers(
             # Operation is two-qubit
             assert cirq.num_qubits(op) == 2
             # Operation fits pattern
-            assert op.qubits in pattern[i % len(pattern)]
+            assert (
+                op.qubits in pattern[i % len(pattern)]
+                or op.qubits[::-1] in pattern[i % len(pattern)]
+            )
             active_pairs.add(op.qubits)
         # All interactions that should be in this layer are present
         assert all(

Diff for: cirq-core/cirq/ops/dense_pauli_string.py

@@ -570,6 +570,9 @@ def copy(
     def __str__(self) -> str:
         return super().__str__() + ' (mutable)'
 
+    def _value_equality_values_(self):
+        return self.coefficient, tuple(PAULI_CHARS[p] for p in self.pauli_mask)
+
     @classmethod
     def inline_gaussian_elimination(cls, rows: 'List[MutableDensePauliString]') -> None:
         if not rows:

Diff for: cirq-core/cirq/ops/linear_combinations.py

@@ -357,7 +357,7 @@ def _pauli_string_from_unit(unit: UnitPauliStringT, coefficient: Union[int, floa
     return PauliString(qubit_pauli_map=dict(unit), coefficient=coefficient)
 
 
-@value.value_equality(approximate=True)
+@value.value_equality(approximate=True, unhashable=True)
 class PauliSum:
     """Represents operator defined by linear combination of PauliStrings.
 

Diff for: cirq-core/cirq/protocols/json_serialization.py

@@ -113,7 +113,7 @@ def _register_resolver(dict_factory: Callable[[], Dict[str, ObjectFactory]]) ->
 class SupportsJSON(Protocol):
     """An object that can be turned into JSON dictionaries.
 
-    The magic method _json_dict_ must return a trivially json-serializable
+    The magic method `_json_dict_` must return a trivially json-serializable
     type or other objects that support the SupportsJSON protocol.
 
     During deserialization, a class must be able to be resolved (see
@@ -150,7 +150,7 @@ def obj_to_dict_helper(obj: Any, attribute_names: Iterable[str]) -> Dict[str, An
     """Construct a dictionary containing attributes from obj
 
     This is useful as a helper function in objects implementing the
-    SupportsJSON protocol, particularly in the _json_dict_ method.
+    SupportsJSON protocol, particularly in the `_json_dict_` method.
 
     In addition to keys and values specified by `attribute_names`, the
     returned dictionary has an additional key "cirq_type" whose value
@@ -169,7 +169,7 @@ def obj_to_dict_helper(obj: Any, attribute_names: Iterable[str]) -> Dict[str, An
 
 # pylint: enable=redefined-builtin
 def dataclass_json_dict(obj: Any) -> Dict[str, Any]:
-    """Return a dictionary suitable for _json_dict_ from a dataclass.
+    """Return a dictionary suitable for `_json_dict_` from a dataclass.
 
     Dataclasses keep track of their relevant fields, so we can automatically generate these.
 
@@ -607,7 +607,7 @@ def to_json(
         cls: Passed to json.dump; the default value of CirqEncoder
             enables the serialization of Cirq objects which implement
             the SupportsJSON protocol. To support serialization of 3rd
-            party classes, prefer adding the _json_dict_ magic method
+            party classes, prefer adding the `_json_dict_` magic method
             to your classes rather than overriding this default.
     """
     if has_serializable_by_keys(obj):

Diff for: cirq-core/cirq/sim/density_matrix_simulation_state.py

@@ -285,6 +285,22 @@ def __init__(
         )
         super().__init__(state=state, prng=prng, qubits=qubits, classical_data=classical_data)
 
+    def add_qubits(self, qubits: Sequence['cirq.Qid']):
+        ret = super().add_qubits(qubits)
+        return (
+            self.kronecker_product(type(self)(qubits=qubits), inplace=True)
+            if ret is NotImplemented
+            else ret
+        )
+
+    def remove_qubits(self, qubits: Sequence['cirq.Qid']):
+        ret = super().remove_qubits(qubits)
+        if ret is not NotImplemented:
+            return ret
+        extracted, remainder = self.factor(qubits, inplace=True)
+        remainder._state._density_matrix *= extracted._state._density_matrix.reshape(-1)[0]
+        return remainder
+
     def _act_on_fallback_(
         self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
     ) -> bool:

Diff for: cirq-core/cirq/sim/simulation_state_test.py

@@ -164,9 +164,8 @@ def test_delegating_gate_channel(exp):
     control_circuit = cirq.Circuit(cirq.H(q))
     control_circuit.append(cirq.ZPowGate(exponent=exp).on(q))
 
-    with pytest.raises(TypeError, match="DensityMatrixSimulator doesn't support"):
-        # TODO: This test should pass once we extend support to DensityMatrixSimulator.
-        assert_test_circuit_for_dm_simulator(test_circuit, control_circuit)
+    assert_test_circuit_for_sv_simulator(test_circuit, control_circuit)
+    assert_test_circuit_for_dm_simulator(test_circuit, control_circuit)
 
 
 @pytest.mark.parametrize('num_ancilla', [1, 2, 3])