JSON Protocol

cirq/__init__.py

@@ -329,6 +329,7 @@
     qasm,
     QasmArgs,
     qid_shape,
+    read_json,
     resolve_parameters,
     SupportsApplyChannel,
     SupportsConsistentApplyUnitary,
@@ -347,6 +348,8 @@
     SupportsQasmWithArgsAndQubits,
     SupportsTraceDistanceBound,
     SupportsUnitary,
+    to_json,
+    to_json_dict,
     trace_distance_bound,
     unitary,
     validate_mixture,

cirq/devices/grid_qubit.py

@@ -15,7 +15,7 @@
 
 from typing import Dict, List, Tuple
 
-from cirq import ops
+from cirq import ops, protocols
 
 
 class GridQubit(ops.Qid):
@@ -139,6 +139,9 @@ def __repr__(self):
     def __str__(self):
         return '({}, {})'.format(self.row, self.col)
 
+    def _json_dict_(self):
+        return protocols.to_json_dict(self, ['row', 'col'])
+
     def __add__(self, other: Tuple[int, int]) -> 'GridQubit':
         if not (isinstance(other, tuple) and len(other) == 2 and
                 all(isinstance(x, int) for x in other)):

cirq/devices/grid_qubit_test.py

@@ -167,3 +167,13 @@ def test_from_proto_bad_dict():
         cirq.GridQubit.from_proto_dict({})
     with pytest.raises(ValueError):
         cirq.GridQubit.from_proto_dict({'nothing': 1})
+
+
+def test_to_json():
+    q = cirq.GridQubit(5, 6)
+    d = q._json_dict_()
+    assert d == {
+        'cirq_type': 'GridQubit',
+        'row': 5,
+        'col': 6,
+    }

cirq/line/line_qubit.py

@@ -15,7 +15,7 @@
 import functools
 from typing import List
 
-from cirq import ops
+from cirq import ops, protocols
 
 @functools.total_ordering
 class LineQubit(ops.Qid):
@@ -84,3 +84,6 @@ def __rsub__(self, other: int) -> 'LineQubit':
 
     def __neg__(self) -> 'LineQubit':
         return LineQubit(-self.x)
+
+    def _json_dict_(self):
+        return protocols.to_json_dict(self, ['x'])

cirq/line/line_qubit_test.py

@@ -107,3 +107,10 @@ def test_addition_subtraction_type_error():
 
 def test_neg():
     assert -cirq.LineQubit(1) == cirq.LineQubit(-1)
+
+
+def test_json_dict():
+    assert cirq.LineQubit(5)._json_dict_() == {
+        'cirq_type': 'LineQubit',
+        'x': 5,
+    }

cirq/ops/common_gates.py

@@ -552,6 +552,17 @@ def __repr__(self):
     def _value_equality_values_(self):
         return self.num_qubits(), self.key, self.invert_mask
 
+    def _json_dict_(self):
+        return {'cirq_type': self.__class__.__name__,
+                'num_qubits': self.num_qubits(),
+                'key': self.key,
+                'invert_mask': self.invert_mask}
+
+    @classmethod
+    def _from_json_dict_(cls, num_qubits, key, invert_mask, **kwargs):
+        return cls(num_qubits=num_qubits, key=key,
+                   invert_mask=tuple(invert_mask))
+
 
 def _default_measurement_key(qubits: Iterable[raw_types.Qid]) -> str:
     return ','.join(str(q) for q in qubits)
@@ -665,6 +676,10 @@ def _qasm_(self, args: protocols.QasmArgs,
     def _value_equality_values_(self):
         return self.num_qubits(),
 
+    def _json_dict_(self):
+        return {'cirq_type': self.__class__.__name__,
+                'num_qubits': self._num_qubits}
+
 
 class HPowGate(eigen_gate.EigenGate, gate_features.SingleQubitGate):
     """A Gate that performs a rotation around the X+Z axis of the Bloch sphere.

cirq/ops/eigen_gate.py

@@ -109,6 +109,10 @@ def __init__(self, *,  # Forces keyword args.
     def exponent(self) -> Union[sympy.Basic, float]:
         return self._exponent
 
+    @property
+    def global_shift(self) -> float:
+        return self._global_shift
+
     # virtual method
     def _with_exponent(self: TSelf,
                        exponent: Union[sympy.Basic, float]) -> TSelf:
@@ -318,6 +322,9 @@ def _resolve_parameters_(self: TSelf, param_resolver) -> TSelf:
         return self._with_exponent(
                 exponent=param_resolver.value_of(self._exponent))
 
+    def _json_dict_(self):
+        return protocols.to_json_dict(self, ['exponent', 'global_shift'])
+
 
 def _lcm(vals: Iterable[int]) -> int:
     t = 1

cirq/ops/fsim_gate.py

@@ -154,6 +154,9 @@ def __repr__(self):
         return 'cirq.FSimGate(theta={}, phi={})'.format(proper_repr(self.theta),
                                                         proper_repr(self.phi))
 
+    def _json_dict_(self):
+        return protocols.to_json_dict(self, ['theta', 'phi'])
+
 
 def _format_rads(args: 'cirq.CircuitDiagramInfoArgs', radians: float) -> str:
     if cirq.is_parameterized(radians):

cirq/ops/fsim_gate_test.py

@@ -234,3 +234,11 @@ def test_fsim_iswap_cphase(theta, phi):
     iswap_cphase = cirq.Circuit.from_ops((iswap.on(q0, q1), cphase.on(q0, q1)))
     fsim = cirq.FSimGate(theta=theta, phi=phi)
     assert np.allclose(cirq.unitary(iswap_cphase), cirq.unitary(fsim))
+
+
+def test_fsim_json_dict():
+    assert cirq.FSimGate(theta=0.123, phi=0.456)._json_dict_() == {
+        'cirq_type': 'FSimGate',
+        'theta': 0.123,
+        'phi': 0.456,
+    }

cirq/ops/gate_operation.py

@@ -71,6 +71,9 @@ def __str__(self):
         return '{}({})'.format(self.gate,
                                ', '.join(str(e) for e in self.qubits))
 
+    def _json_dict_(self):
+        return protocols.to_json_dict(self, ['gate', 'qubits'])
+
     def _group_interchangeable_qubits(self) -> Tuple[
             Union[raw_types.Qid,
                   Tuple[int, FrozenSet[raw_types.Qid]]],

cirq/ops/global_phase_op.py

@@ -15,7 +15,7 @@
 
 import numpy as np
 
-from cirq import value
+from cirq import value, protocols
 from cirq.ops import raw_types
 
 
@@ -62,3 +62,6 @@ def __str__(self):
 
     def __repr__(self):
         return 'cirq.GlobalPhaseOperation({!r})'.format(self.coefficient)
+
+    def _json_dict_(self):
+        return protocols.to_json_dict(self, ['coefficient'])

cirq/ops/global_phase_op_test.py

@@ -182,3 +182,10 @@ def test_diagram():
         ]), """
 global phase:   -0.5π
         """)
+
+
+def test_global_phase_op_json_dict():
+    assert cirq.GlobalPhaseOperation(-1j)._json_dict_() == {
+        'cirq_type': 'GlobalPhaseOperation',
+        'coefficient': -1j,
+    }

cirq/ops/pauli_gates.py

@@ -59,7 +59,7 @@ def phased_pauli_product(
     ) -> Tuple[complex, Union['Pauli', 'common_gates.IdentityGate']]:
         if self == other:
             return 1, common_gates.I
-        return 1j**other.relative_index(self), self.third(other)
+        return 1j ** other.relative_index(self), self.third(other)
 
     def __gt__(self, other):
         if not isinstance(other, Pauli):
@@ -94,6 +94,11 @@ def __pow__(self: '_PauliX',
                 exponent: Union[sympy.Basic, float]) -> common_gates.XPowGate:
         return common_gates.XPowGate(exponent=exponent)
 
+    @classmethod
+    def _from_json_dict_(cls, exponent, global_shift, **kwargs):
+        assert global_shift == 0
+        return cls(exponent=exponent)
+
 
 class _PauliY(Pauli, common_gates.YPowGate):
     def __init__(self, *, exponent: Union[sympy.Basic, float] = 1.0):
@@ -104,6 +109,11 @@ def __pow__(self: '_PauliY',
                 exponent: Union[sympy.Basic, float]) -> common_gates.YPowGate:
         return common_gates.YPowGate(exponent=exponent)
 
+    @classmethod
+    def _from_json_dict_(cls, exponent, global_shift, **kwargs):
+        assert global_shift == 0
+        return cls(exponent=exponent)
+
 
 class _PauliZ(Pauli, common_gates.ZPowGate):
     def __init__(self, *, exponent: Union[sympy.Basic, float] = 1.0):
@@ -114,6 +124,11 @@ def __pow__(self: '_PauliZ',
                 exponent: Union[sympy.Basic, float]) -> common_gates.ZPowGate:
         return common_gates.ZPowGate(exponent=exponent)
 
+    @classmethod
+    def _from_json_dict_(cls, exponent, global_shift, **kwargs):
+        assert global_shift == 0
+        return cls(exponent=exponent)
+
 
 # The Pauli X gate.
 #
@@ -123,7 +138,6 @@ def __pow__(self: '_PauliZ',
 #    [1, 0]]
 X = _PauliX()
 
-
 # The Pauli Y gate.
 #
 # Matrix:
@@ -132,7 +146,6 @@ def __pow__(self: '_PauliZ',
 #      [i, 0]]
 Y = _PauliY()
 
-
 # The Pauli Z gate.
 #
 # Matrix:
@@ -141,5 +154,4 @@ def __pow__(self: '_PauliZ',
 #      [0, -1]]
 Z = _PauliZ()
 
-
 Pauli._XYZ = (X, Y, Z)

cirq/ops/raw_types.py

@@ -18,7 +18,7 @@
 
 import abc
 
-from cirq import value
+from cirq import value, protocols
 from cirq.protocols import decompose, inverse, qid_shape_protocol
 
 if TYPE_CHECKING:
@@ -255,6 +255,9 @@ def _qid_shape_(self) -> Tuple[int, ...]:
         (3, 3) for a 2-qutrit ternary gate.
         """
 
+    def _json_dict_(self):
+        return protocols.to_json_dict(self, attribute_names=[])
+
 
 class Operation(metaclass=abc.ABCMeta):
     """An effect applied to a collection of qubits.

cirq/ops/raw_types_test.py

@@ -275,3 +275,10 @@ def _qid_shape_(self):
     assert len(shape_op.qubits) == 4
     assert cirq.qid_shape(shape_op) == (1, 2, 3, 4)
     assert cirq.num_qubits(shape_op) == 4
+
+
+def test_gate_json_dict():
+    g = cirq.CSWAP  # not an eigen gate (which has its own _json_dict_)
+    assert g._json_dict_() == {
+        'cirq_type': 'CSwapGate',
+    }

cirq/protocols/__init__.py

@@ -54,6 +54,9 @@
 from cirq.protocols.inverse import (
     inverse,
 )
+from cirq.protocols.json import (
+    to_json, read_json, to_json_dict
+)
 from cirq.protocols.measurement_key import (
     is_measurement,
     measurement_key,