cirq-core 1.1.0.dev20221220224914__py3-none-any.whl → 1.2.0__py3-none-any.whl

cirq/protocols/decompose_protocol.py

@@ -11,13 +11,17 @@
 # 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 dataclasses
+import inspect
+from collections import defaultdict
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
     Dict,
     Iterable,
+    Iterator,
     List,
     Optional,
     overload,
@@ -26,7 +30,7 @@ from typing import (
     TypeVar,
     Union,
 )
-from collections import defaultdict
+from typing_extensions import runtime_checkable
 
 from typing_extensions import Protocol
 
@@ -45,7 +49,19 @@ TError = TypeVar('TError', bound=Exception)
 RaiseTypeErrorIfNotProvided: Any = ([],)
 
 DecomposeResult = Union[None, NotImplementedType, 'cirq.OP_TREE']
-OpDecomposer = Callable[['cirq.Operation'], DecomposeResult]
+
+_CONTEXT_COUNTER = itertools.count()  # Use _reset_context_counter() to reset the counter.
+
+
+@runtime_checkable
+class OpDecomposerWithContext(Protocol):
+    def __call__(
+        self, __op: 'cirq.Operation', *, context: Optional['cirq.DecompositionContext'] = None
+    ) -> DecomposeResult:
+        ...
+
+
+OpDecomposer = Union[Callable[['cirq.Operation'], DecomposeResult], OpDecomposerWithContext]
 
 DECOMPOSE_TARGET_GATESET = ops.Gateset(
     ops.XPowGate,
@@ -61,6 +77,18 @@ def _value_error_describing_bad_operation(op: 'cirq.Operation') -> ValueError:
     return ValueError(f"Operation doesn't satisfy the given `keep` but can't be decomposed: {op!r}")
 
 
+@dataclasses.dataclass(frozen=True)
+class DecompositionContext:
+    """Stores common configurable options for decomposing composite gates into simpler operations.
+
+    Args:
+        qubit_manager: A `cirq.QubitManager` instance to allocate clean / dirty ancilla qubits as
+            part of the decompose protocol.
+    """
+
+    qubit_manager: 'cirq.QubitManager'
+
+
 class SupportsDecompose(Protocol):
     """An object that can be decomposed into simpler operations.
 
@@ -104,6 +132,11 @@ class SupportsDecompose(Protocol):
     def _decompose_(self) -> DecomposeResult:
         pass
 
+    def _decompose_with_context_(
+        self, *, context: Optional[DecompositionContext] = None
+    ) -> DecomposeResult:
+        pass
+
 
 class SupportsDecomposeWithQubits(Protocol):
     """An object that can be decomposed into operations on given qubits.
@@ -127,6 +160,72 @@ class SupportsDecomposeWithQubits(Protocol):
     def _decompose_(self, qubits: Tuple['cirq.Qid', ...]) -> DecomposeResult:
         pass
 
+    def _decompose_with_context_(
+        self, qubits: Tuple['cirq.Qid', ...], *, context: Optional[DecompositionContext] = None
+    ) -> DecomposeResult:
+        pass
+
+
+def _try_op_decomposer(
+    val: Any, decomposer: Optional[OpDecomposer], *, context: Optional[DecompositionContext] = None
+) -> DecomposeResult:
+    if decomposer is None or not isinstance(val, ops.Operation):
+        return None
+    if 'context' in inspect.signature(decomposer).parameters:
+        assert isinstance(decomposer, OpDecomposerWithContext)
+        return decomposer(val, context=context)
+    else:
+        return decomposer(val)
+
+
+@dataclasses.dataclass(frozen=True)
+class _DecomposeArgs:
+    context: Optional[DecompositionContext]
+    intercepting_decomposer: Optional[OpDecomposer]
+    fallback_decomposer: Optional[OpDecomposer]
+    keep: Optional[Callable[['cirq.Operation'], bool]]
+    on_stuck_raise: Union[None, Exception, Callable[['cirq.Operation'], Optional[Exception]]]
+    preserve_structure: bool
+
+
+def _decompose_dfs(item: Any, args: _DecomposeArgs) -> Iterator['cirq.Operation']:
+    from cirq.circuits import CircuitOperation, FrozenCircuit
+
+    if isinstance(item, ops.Operation):
+        item_untagged = item.untagged
+        if args.preserve_structure and isinstance(item_untagged, CircuitOperation):
+            new_fc = FrozenCircuit(_decompose_dfs(item_untagged.circuit, args))
+            yield item_untagged.replace(circuit=new_fc).with_tags(*item.tags)
+            return
+        if args.keep is not None and args.keep(item):
+            yield item
+            return
+
+    decomposed = _try_op_decomposer(item, args.intercepting_decomposer, context=args.context)
+
+    if decomposed is NotImplemented or decomposed is None:
+        decomposed = decompose_once(item, default=None, flatten=False, context=args.context)
+
+    if decomposed is NotImplemented or decomposed is None:
+        decomposed = _try_op_decomposer(item, args.fallback_decomposer, context=args.context)
+
+    if decomposed is NotImplemented or decomposed is None:
+        if not isinstance(item, ops.Operation) and isinstance(item, Iterable):
+            decomposed = item
+
+    if decomposed is NotImplemented or decomposed is None:
+        if args.keep is not None and args.on_stuck_raise is not None:
+            if isinstance(args.on_stuck_raise, Exception):
+                raise args.on_stuck_raise
+            elif callable(args.on_stuck_raise):
+                error = args.on_stuck_raise(item)
+                if error is not None:
+                    raise error
+        yield item
+    else:
+        for val in ops.flatten_to_ops(decomposed):
+            yield from _decompose_dfs(val, args)
+
 
 def decompose(
     val: Any,
@@ -138,6 +237,7 @@ def decompose(
         None, Exception, Callable[['cirq.Operation'], Optional[Exception]]
     ] = _value_error_describing_bad_operation,
     preserve_structure: bool = False,
+    context: Optional[DecompositionContext] = None,
 ) -> List['cirq.Operation']:
     """Recursively decomposes a value into `cirq.Operation`s meeting a criteria.
 
@@ -169,6 +269,8 @@ def decompose(
         preserve_structure: Prevents subcircuits (i.e. `CircuitOperation`s)
             from being decomposed, but decomposes their contents. If this is
             True, `intercepting_decomposer` cannot be specified.
+        context: Decomposition context specifying common configurable options for
+            controlling the behavior of decompose.
 
     Returns:
         A list of operations that the given value was decomposed into. If
@@ -200,55 +302,17 @@ def decompose(
             "acceptable to keep."
         )
 
-    if preserve_structure:
-        return _decompose_preserving_structure(
-            val,
-            intercepting_decomposer=intercepting_decomposer,
-            fallback_decomposer=fallback_decomposer,
-            keep=keep,
-            on_stuck_raise=on_stuck_raise,
-        )
-
-    def try_op_decomposer(val: Any, decomposer: Optional[OpDecomposer]) -> DecomposeResult:
-        if decomposer is None or not isinstance(val, ops.Operation):
-            return None
-        return decomposer(val)
-
-    output = []
-    queue: List[Any] = [val]
-    while queue:
-        item = queue.pop(0)
-        if isinstance(item, ops.Operation) and keep is not None and keep(item):
-            output.append(item)
-            continue
-
-        decomposed = try_op_decomposer(item, intercepting_decomposer)
-
-        if decomposed is NotImplemented or decomposed is None:
-            decomposed = decompose_once(item, default=None)
-
-        if decomposed is NotImplemented or decomposed is None:
-            decomposed = try_op_decomposer(item, fallback_decomposer)
-
-        if decomposed is not NotImplemented and decomposed is not None:
-            queue[:0] = ops.flatten_to_ops(decomposed)
-            continue
-
-        if not isinstance(item, ops.Operation) and isinstance(item, Iterable):
-            queue[:0] = ops.flatten_to_ops(item)
-            continue
-
-        if keep is not None and on_stuck_raise is not None:
-            if isinstance(on_stuck_raise, Exception):
-                raise on_stuck_raise
-            elif callable(on_stuck_raise):
-                error = on_stuck_raise(item)
-                if error is not None:
-                    raise error
-
-        output.append(item)
-
-    return output
+    if context is None:
+        context = DecompositionContext(ops.SimpleQubitManager(prefix='_decompose_protocol'))
+    args = _DecomposeArgs(
+        context=context,
+        intercepting_decomposer=intercepting_decomposer,
+        fallback_decomposer=fallback_decomposer,
+        keep=keep,
+        on_stuck_raise=on_stuck_raise,
+        preserve_structure=preserve_structure,
+    )
+    return [*_decompose_dfs(val, args)]
 
 
 # pylint: disable=function-redefined
@@ -261,12 +325,19 @@ def decompose_once(val: Any, **kwargs) -> List['cirq.Operation']:
 
 @overload
 def decompose_once(
-    val: Any, default: TDefault, *args, **kwargs
+    val: Any, default: TDefault, *args, flatten: bool = True, **kwargs
 ) -> Union[TDefault, List['cirq.Operation']]:
     pass
 
 
-def decompose_once(val: Any, default=RaiseTypeErrorIfNotProvided, *args, **kwargs):
+def decompose_once(
+    val: Any,
+    default=RaiseTypeErrorIfNotProvided,
+    *args,
+    flatten: bool = True,
+    context: Optional[DecompositionContext] = None,
+    **kwargs,
+):
     """Decomposes a value into operations, if possible.
 
     This method decomposes the value exactly once, instead of decomposing it
@@ -282,6 +353,9 @@ def decompose_once(val: Any, default=RaiseTypeErrorIfNotProvided, *args, **kwarg
         *args: Positional arguments to forward into the `_decompose_` method of
             `val`.  For example, this is used to tell gates what qubits they are
             being applied to.
+        flatten: If True, the returned OP-TREE will be flattened to a list of operations.
+        context: Decomposition context specifying common configurable options for
+            controlling the behavior of decompose.
         **kwargs: Keyword arguments to forward into the `_decompose_` method of
             `val`.
 
@@ -295,36 +369,62 @@ def decompose_once(val: Any, default=RaiseTypeErrorIfNotProvided, *args, **kwarg
         TypeError: `val` didn't have a `_decompose_` method (or that method returned
             `NotImplemented` or `None`) and `default` wasn't set.
     """
-    method = getattr(val, '_decompose_', None)
-    decomposed = NotImplemented if method is None else method(*args, **kwargs)
+    if context is None:
+        context = DecompositionContext(
+            ops.SimpleQubitManager(prefix=f'_decompose_protocol_{next(_CONTEXT_COUNTER)}')
+        )
+
+    method = getattr(val, '_decompose_with_context_', None)
+    decomposed = NotImplemented if method is None else method(*args, **kwargs, context=context)
+    if decomposed is NotImplemented or None:
+        method = getattr(val, '_decompose_', None)
+        decomposed = NotImplemented if method is None else method(*args, **kwargs)
 
     if decomposed is not NotImplemented and decomposed is not None:
-        return list(ops.flatten_op_tree(decomposed))
+        return list(ops.flatten_to_ops(decomposed)) if flatten else decomposed
 
     if default is not RaiseTypeErrorIfNotProvided:
         return default
     if method is None:
-        raise TypeError(f"object of type '{type(val)}' has no _decompose_ method.")
+        raise TypeError(
+            f"object of type '{type(val)}' has no _decompose_with_context_ or "
+            f"_decompose_ method."
+        )
     raise TypeError(
-        "object of type '{}' does have a _decompose_ method, "
-        "but it returned NotImplemented or None.".format(type(val))
+        f"object of type {type(val)} does have a _decompose_ method, "
+        "but it returned NotImplemented or None."
     )
 
 
 @overload
-def decompose_once_with_qubits(val: Any, qubits: Iterable['cirq.Qid']) -> List['cirq.Operation']:
+def decompose_once_with_qubits(
+    val: Any,
+    qubits: Iterable['cirq.Qid'],
+    *,
+    flatten: bool = True,
+    context: Optional['DecompositionContext'] = None,
+) -> List['cirq.Operation']:
     pass
 
 
 @overload
 def decompose_once_with_qubits(
-    val: Any, qubits: Iterable['cirq.Qid'], default: Optional[TDefault]
+    val: Any,
+    qubits: Iterable['cirq.Qid'],
+    default: Optional[TDefault],
+    *,
+    flatten: bool = True,
+    context: Optional['DecompositionContext'] = None,
 ) -> Union[TDefault, List['cirq.Operation']]:
     pass
 
 
 def decompose_once_with_qubits(
-    val: Any, qubits: Iterable['cirq.Qid'], default=RaiseTypeErrorIfNotProvided
+    val: Any,
+    qubits: Iterable['cirq.Qid'],
+    default=RaiseTypeErrorIfNotProvided,
+    flatten: bool = True,
+    context: Optional['DecompositionContext'] = None,
 ):
     """Decomposes a value into operations on the given qubits.
 
@@ -341,6 +441,9 @@ def decompose_once_with_qubits(
             `_decompose_` method or that method returns `NotImplemented` or
             `None`. If not specified, non-decomposable values cause a
             `TypeError`.
+        flatten: If True, the returned OP-TREE will be flattened to a list of operations.
+        context: Decomposition context specifying common configurable options for
+            controlling the behavior of decompose.
 
     Returns:
         The result of `val._decompose_(qubits)`, if `val` has a
@@ -352,7 +455,7 @@ def decompose_once_with_qubits(
         `val` didn't have a `_decompose_` method (or that method returned
         `NotImplemented` or `None`) and `default` wasn't set.
     """
-    return decompose_once(val, default, tuple(qubits))
+    return decompose_once(val, default, tuple(qubits), flatten=flatten, context=context)
 
 
 # pylint: enable=function-redefined
@@ -383,65 +486,4 @@ def _try_decompose_into_operations_and_qubits(
                 qid_shape_dict[q] = max(qid_shape_dict[q], level)
         qubits = sorted(qubit_set)
         return result, qubits, tuple(qid_shape_dict[q] for q in qubits)
-
     return None, (), ()
-
-
-def _decompose_preserving_structure(
-    val: Any,
-    *,
-    intercepting_decomposer: Optional[OpDecomposer] = None,
-    fallback_decomposer: Optional[OpDecomposer] = None,
-    keep: Optional[Callable[['cirq.Operation'], bool]] = None,
-    on_stuck_raise: Union[
-        None, Exception, Callable[['cirq.Operation'], Optional[Exception]]
-    ] = _value_error_describing_bad_operation,
-) -> List['cirq.Operation']:
-    """Preserves structure (e.g. subcircuits) while decomposing ops.
-
-    This can be used to reduce a circuit to a particular gateset without
-    increasing its serialization size. See tests for examples.
-    """
-
-    # This method provides a generated 'keep' to its decompose() calls.
-    # If the user-provided keep is not set, on_stuck_raise must be unset to
-    # ensure that failure to decompose does not generate errors.
-    on_stuck_raise = on_stuck_raise if keep is not None else None
-
-    from cirq.circuits import CircuitOperation, FrozenCircuit
-
-    visited_fcs = set()
-
-    def keep_structure(op: 'cirq.Operation'):
-        circuit = getattr(op.untagged, 'circuit', None)
-        if circuit is not None:
-            return circuit in visited_fcs
-        if keep is not None and keep(op):
-            return True
-
-    def dps_interceptor(op: 'cirq.Operation'):
-        if not isinstance(op.untagged, CircuitOperation):
-            if intercepting_decomposer is None:
-                return NotImplemented
-            return intercepting_decomposer(op)
-
-        new_fc = FrozenCircuit(
-            decompose(
-                op.untagged.circuit,
-                intercepting_decomposer=dps_interceptor,
-                fallback_decomposer=fallback_decomposer,
-                keep=keep_structure,
-                on_stuck_raise=on_stuck_raise,
-            )
-        )
-        visited_fcs.add(new_fc)
-        new_co = op.untagged.replace(circuit=new_fc)
-        return new_co if not op.tags else new_co.with_tags(*op.tags)
-
-    return decompose(
-        val,
-        intercepting_decomposer=dps_interceptor,
-        fallback_decomposer=fallback_decomposer,
-        keep=keep_structure,
-        on_stuck_raise=on_stuck_raise,
-    )

cirq/protocols/decompose_protocol_test.py

@@ -11,6 +11,9 @@
 # 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
+from typing import Optional
+from unittest import mock
 import pytest
 
 import cirq
@@ -59,7 +62,7 @@ class DecomposeQuditGate:
 
 def test_decompose_once():
     # No default value results in descriptive error.
-    with pytest.raises(TypeError, match='no _decompose_ method'):
+    with pytest.raises(TypeError, match='no _decompose_with_context_ or _decompose_ method'):
         _ = cirq.decompose_once(NoMethod())
     with pytest.raises(TypeError, match='returned NotImplemented or None'):
         _ = cirq.decompose_once(DecomposeNotImplemented())
@@ -88,7 +91,7 @@ def test_decompose_once_with_qubits():
     qs = cirq.LineQubit.range(3)
 
     # No default value results in descriptive error.
-    with pytest.raises(TypeError, match='no _decompose_ method'):
+    with pytest.raises(TypeError, match='no _decompose_with_context_ or _decompose_ method'):
         _ = cirq.decompose_once_with_qubits(NoMethod(), qs)
     with pytest.raises(TypeError, match='returned NotImplemented or None'):
         _ = cirq.decompose_once_with_qubits(DecomposeNotImplemented(), qs)
@@ -222,6 +225,23 @@ def test_decompose_intercept():
     )
     assert actual == [cirq.CNOT(a, b), cirq.CNOT(b, a), cirq.CNOT(a, b)]
 
+    # Accepts a context, when provided.
+    def _intercept_with_context(
+        op: cirq.Operation, context: Optional[cirq.DecompositionContext] = None
+    ):
+        assert context is not None
+        if op.gate == cirq.SWAP:
+            q = context.qubit_manager.qalloc(1)
+            a, b = op.qubits
+            return [cirq.X(a), cirq.X(*q), cirq.X(b)]
+        return NotImplemented
+
+    context = cirq.DecompositionContext(cirq.ops.SimpleQubitManager())
+    actual = cirq.decompose(
+        cirq.SWAP(a, b), intercepting_decomposer=_intercept_with_context, context=context
+    )
+    assert actual == [cirq.X(a), cirq.X(cirq.ops.CleanQubit(0)), cirq.X(b)]
+
 
 def test_decompose_preserving_structure():
     a, b = cirq.LineQubit.range(2)
@@ -308,3 +328,113 @@ def test_decompose_tagged_operation():
         'tag',
     )
     assert cirq.decompose_once(op) == cirq.decompose_once(op.untagged)
+
+
+class RecursiveDecompose(cirq.Gate):
+    def __init__(
+        self,
+        recurse: bool = True,
+        mock_qm=mock.Mock(spec=cirq.QubitManager),
+        with_context: bool = False,
+    ):
+        self.recurse = recurse
+        self.mock_qm = mock_qm
+        self.with_context = with_context
+
+    def _num_qubits_(self) -> int:
+        return 2
+
+    def _decompose_impl(self, qubits, mock_qm: mock.Mock):
+        mock_qm.qalloc(self.recurse)
+        yield RecursiveDecompose(
+            recurse=False, mock_qm=self.mock_qm, with_context=self.with_context
+        ).on(*qubits) if self.recurse else cirq.Z.on_each(*qubits)
+        mock_qm.qfree(self.recurse)
+
+    def _decompose_(self, qubits):
+        if self.with_context:
+            assert False
+        else:
+            return self._decompose_impl(qubits, self.mock_qm)
+
+    def _decompose_with_context_(self, qubits, context):
+        if self.with_context:
+            qm = self.mock_qm if context is None else context.qubit_manager
+            return self._decompose_impl(qubits, qm)
+        else:
+            return NotImplemented
+
+    def _has_unitary_(self):
+        return True
+
+
+@pytest.mark.parametrize('with_context', [True, False])
+def test_decompose_recursive_dfs(with_context: bool):
+    expected_calls = [
+        mock.call.qalloc(True),
+        mock.call.qalloc(False),
+        mock.call.qfree(False),
+        mock.call.qfree(True),
+    ]
+    mock_qm = mock.Mock(spec=cirq.QubitManager)
+    context_qm = mock.Mock(spec=cirq.QubitManager)
+    gate = RecursiveDecompose(mock_qm=mock_qm, with_context=with_context)
+    q = cirq.LineQubit.range(3)
+    gate_op = gate.on(*q[:2])
+    tagged_op = gate_op.with_tags("custom tag")
+    controlled_op = gate_op.controlled_by(q[2])
+    classically_controlled_op = gate_op.with_classical_controls('key')
+    moment = cirq.Moment(gate_op)
+    circuit = cirq.Circuit(moment)
+    for val in [gate_op, tagged_op, controlled_op, classically_controlled_op, moment, circuit]:
+        mock_qm.reset_mock()
+        _ = cirq.decompose(val, context=cirq.DecompositionContext(qubit_manager=mock_qm))
+        assert mock_qm.method_calls == expected_calls
+
+        mock_qm.reset_mock()
+        context_qm.reset_mock()
+        _ = cirq.decompose(val, context=cirq.DecompositionContext(context_qm))
+        assert (
+            context_qm.method_calls == expected_calls
+            if with_context
+            else mock_qm.method_calls == expected_calls
+        )
+
+
+class G1(cirq.Gate):
+    def _num_qubits_(self) -> int:
+        return 1
+
+    def _decompose_with_context_(self, qubits, context):
+        yield cirq.CNOT(qubits[0], context.qubit_manager.qalloc(1)[0])
+
+
+class G2(cirq.Gate):
+    def _num_qubits_(self) -> int:
+        return 1
+
+    def _decompose_with_context_(self, qubits, context):
+        yield G1()(*context.qubit_manager.qalloc(1))
+
+
+@mock.patch('cirq.protocols.decompose_protocol._CONTEXT_COUNTER', itertools.count())
+def test_successive_decompose_once_succeed():
+    op = G2()(cirq.NamedQubit('q'))
+    d1 = cirq.decompose_once(op)
+    d2 = cirq.decompose_once(d1[0])
+    assert d2 == [
+        cirq.CNOT(
+            cirq.ops.CleanQubit(0, prefix='_decompose_protocol_0'),
+            cirq.ops.CleanQubit(0, prefix='_decompose_protocol_1'),
+        )
+    ]
+
+
+def test_decompose_without_context_succeed():
+    op = G2()(cirq.NamedQubit('q'))
+    assert cirq.decompose(op, keep=lambda op: op.gate is cirq.CNOT) == [
+        cirq.CNOT(
+            cirq.ops.CleanQubit(0, prefix='_decompose_protocol'),
+            cirq.ops.CleanQubit(1, prefix='_decompose_protocol'),
+        )
+    ]

cirq/protocols/has_stabilizer_effect_protocol.py

@@ -63,7 +63,8 @@ def _strat_has_stabilizer_effect_from_unitary(val: Any) -> Optional[bool]:
     """
     # Do not try this strategy if there is no unitary or if the number of
     # qubits is not 1 since that would be expensive.
-    if not protocols.has_unitary(val) or protocols.num_qubits(val) != 1:
+    qid_shape = protocols.qid_shape(val, default=None)
+    if qid_shape is None or len(qid_shape) != 1 or not protocols.has_unitary(val):
         return None
     unitary = protocols.unitary(val)
     return SingleQubitCliffordGate.from_unitary(unitary) is not None

cirq/protocols/inverse_protocol.py

@@ -115,9 +115,9 @@ def inverse(val: Any, default: Any = RaiseTypeErrorIfNotProvided) -> Any:
     if default is not RaiseTypeErrorIfNotProvided:
         return default
     raise TypeError(
-        "object of type '{}' isn't invertible. "
+        f"object of type '{type(val)}' isn't invertible. "
         "It has no __pow__ method (or the method returned NotImplemented) "
-        "and it isn't an iterable of invertible objects.".format(type(val))
+        "and it isn't an iterable of invertible objects."
     )
 
 

cirq/protocols/json_serialization_test.py

@@ -57,8 +57,8 @@ TESTED_MODULES: Dict[str, Optional[_ModuleDeprecation]] = {
 
 
 # pyQuil 3.0, necessary for cirq_rigetti module requires
-# python >= 3.7
-if sys.version_info < (3, 7):  # pragma: no cover
+# python >= 3.9
+if sys.version_info < (3, 9):  # pragma: no cover
     del TESTED_MODULES['cirq_rigetti']
 
 
@@ -767,7 +767,7 @@ def test_pathlib_paths(tmpdir):
     assert cirq.read_json_gzip(gzip_path) == cirq.X
 
 
-def test_dataclass_json_dict():
+def test_dataclass_json_dict() -> None:
     @dataclasses.dataclass(frozen=True)
     class MyDC:
         q: cirq.LineQubit

cirq/protocols/json_test_data/Linspace.json

@@ -1,7 +1,20 @@
-{
-  "cirq_type": "Linspace",
-  "key": "a",
-  "start": 0,
-  "stop": 1,
-  "length": 4
-}
+[
+    {
+      "cirq_type": "Linspace",
+      "key": "a",
+      "start": 0,
+      "stop": 1,
+      "length": 4
+    },
+    {
+      "cirq_type": "Linspace",
+      "key": "b",
+      "start": 1,
+      "stop": 2,
+      "length": 3,
+      "metadata": {
+              "cirq_type": "NamedQubit",
+              "name": "b"
+      }
+    }
+]

cirq/protocols/json_test_data/Linspace.repr

@@ -1 +1,4 @@
-cirq.Linspace("a", start=0, stop=1, length=4)
+[
+    cirq.Linspace("a", start=0, stop=1, length=4),
+    cirq.Linspace("b", start=1, stop=2, length=3, metadata=cirq.NamedQubit("b"))
+]

cirq/protocols/json_test_data/Points.json

@@ -1,8 +1,19 @@
-{
-  "cirq_type": "Points",
-  "key": "a",
-  "points": [
-    0,
-    0.4
-  ]
-}
+[
+    {
+      "cirq_type": "Points",
+      "key": "a",
+      "points": [
+        0,
+        0.4
+      ]
+    },
+    {
+      "cirq_type": "Points",
+      "key": "amp",
+      "points": [
+        0,
+        1
+      ],
+      "metadata": "used to turn amp on or off"
+    }
+]