Add JSON serialisations

cirq-core/cirq/contrib/__init__.py

@@ -24,3 +24,6 @@
 from cirq.contrib.qcircuit import circuit_to_latex_using_qcircuit as circuit_to_latex_using_qcircuit
 from cirq.contrib import json  # noqa: F401
 from cirq.contrib.circuitdag import CircuitDag as CircuitDag, Unique as Unique
+from cirq.contrib.acquaintance import SwapPermutationGate as SwapPermutationGate
+from cirq.contrib.bayesian_network import BayesianNetworkGate as BayesianNetworkGate
+from cirq.contrib.quantum_volume import QuantumVolumeResult as QuantumVolumeResult

cirq-core/cirq/contrib/json.py

@@ -3,18 +3,46 @@
 
 from __future__ import annotations
 
-from cirq.protocols.json_serialization import DEFAULT_RESOLVERS
+import functools
+from typing import TYPE_CHECKING
+
+from cirq.protocols.json_serialization import _register_resolver, DEFAULT_RESOLVERS
+
+if TYPE_CHECKING:  # pragma: no cover
+    from cirq.protocols.json_serialization import ObjectFactory
 
 
 def contrib_class_resolver(cirq_type: str):
     """Extend cirq's JSON API with resolvers for cirq contrib classes."""
+    return _class_resolver_dictionary().get(cirq_type, None)
+
+
+@functools.lru_cache()
+def _class_resolver_dictionary() -> dict[str, ObjectFactory]:
     from cirq.contrib.acquaintance import SwapPermutationGate
     from cirq.contrib.bayesian_network import BayesianNetworkGate
+    from cirq.contrib.noise_models import (
+        DampedReadoutNoiseModel,
+        DepolarizingNoiseModel,
+        DepolarizingWithDampedReadoutNoiseModel,
+        DepolarizingWithReadoutNoiseModel,
+        ReadoutNoiseModel,
+    )
     from cirq.contrib.quantum_volume import QuantumVolumeResult
 
-    classes = [BayesianNetworkGate, QuantumVolumeResult, SwapPermutationGate]
-    d = {cls.__name__: cls for cls in classes}
-    return d.get(cirq_type, None)
+    classes = [
+        BayesianNetworkGate,
+        QuantumVolumeResult,
+        SwapPermutationGate,
+        DepolarizingNoiseModel,
+        ReadoutNoiseModel,
+        DampedReadoutNoiseModel,
+        DepolarizingWithReadoutNoiseModel,
+        DepolarizingWithDampedReadoutNoiseModel,
+    ]
+    return {cls.__name__: cls for cls in classes}
 
 
 DEFAULT_CONTRIB_RESOLVERS = [contrib_class_resolver] + DEFAULT_RESOLVERS
+
+_register_resolver(_class_resolver_dictionary)

cirq-core/cirq/contrib/json_test_data/DampedReadoutNoiseModel.json

@@ -0,0 +1,5 @@
+{
+  "cirq_type": "DampedReadoutNoiseModel",
+  "decay_prob": 0.3,
+  "prepend": true
+}

cirq-core/cirq/contrib/json_test_data/DampedReadoutNoiseModel.repr

@@ -0,0 +1 @@
+cirq.contrib.noise_models.DampedReadoutNoiseModel(0.3, prepend=True)

cirq-core/cirq/contrib/json_test_data/DepolarizingNoiseModel.json

@@ -0,0 +1,5 @@
+{
+  "cirq_type": "DepolarizingNoiseModel",
+  "depol_prob": 0.1,
+  "prepend": false
+}

cirq-core/cirq/contrib/json_test_data/DepolarizingNoiseModel.repr

@@ -0,0 +1 @@
+cirq.contrib.noise_models.DepolarizingNoiseModel(0.1, prepend=False)

cirq-core/cirq/contrib/json_test_data/DepolarizingWithDampedReadoutNoiseModel.json

@@ -0,0 +1,6 @@
+{
+  "cirq_type": "DepolarizingWithDampedReadoutNoiseModel",
+  "depol_prob": 0.1,
+  "bitflip_prob": 0.2,
+  "decay_prob": 0.3
+}

cirq-core/cirq/contrib/json_test_data/DepolarizingWithDampedReadoutNoiseModel.repr

@@ -0,0 +1 @@
+cirq.contrib.noise_models.DepolarizingWithDampedReadoutNoiseModel(0.1, 0.2, 0.3)

cirq-core/cirq/contrib/json_test_data/DepolarizingWithReadoutNoiseModel.json

@@ -0,0 +1,5 @@
+{
+  "cirq_type": "DepolarizingWithReadoutNoiseModel",
+  "depol_prob": 0.1,
+  "bitflip_prob": 0.2
+}

cirq-core/cirq/contrib/json_test_data/DepolarizingWithReadoutNoiseModel.repr

@@ -0,0 +1 @@
+cirq.contrib.noise_models.DepolarizingWithReadoutNoiseModel(0.1, 0.2)

cirq-core/cirq/contrib/json_test_data/ReadoutNoiseModel.json

@@ -0,0 +1,5 @@
+{
+  "cirq_type": "ReadoutNoiseModel",
+  "bitflip_prob": 0.2,
+  "prepend": true
+}

cirq-core/cirq/contrib/json_test_data/ReadoutNoiseModel.repr

@@ -0,0 +1 @@
+cirq.contrib.noise_models.ReadoutNoiseModel(0.2, prepend=True)

cirq-core/cirq/contrib/json_test_data/__init__.py

@@ -0,0 +1,17 @@
+# Copyright 2025 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.
+
+"""Test data for JSON serialization of :mod:`cirq.contrib` objects."""
+
+from cirq.contrib.json_test_data.spec import TestSpec as TestSpec

cirq-core/cirq/contrib/json_test_data/spec.py

@@ -0,0 +1,35 @@
+# pylint: disable=wrong-or-nonexistent-copyright-notice
+from __future__ import annotations
+
+import pathlib
+
+import cirq
+from cirq.contrib.json import _class_resolver_dictionary
+from cirq.testing.json import ModuleJsonTestSpec
+
+TestSpec = ModuleJsonTestSpec(
+    name="cirq.contrib",
+    packages=[cirq.contrib],
+    test_data_path=pathlib.Path(__file__).parent,
+    not_yet_serializable=[],
+    should_not_be_serialized=[
+        "QuantumVolumeResult",
+        "SwapPermutationGate",
+        "BayesianNetworkGate",
+        "Unique",
+        "CircuitDag",
+    ],
+    resolver_cache={
+        k: v
+        for k, v in _class_resolver_dictionary().items()
+        if k
+        not in {
+            "QuantumVolumeResult",
+            "SwapPermutationGate",
+            "BayesianNetworkGate",
+            "Unique",
+            "CircuitDag",
+        }
+    },
+    deprecated={},
+)

cirq-core/cirq/contrib/noise_models/noise_models.py

@@ -23,6 +23,7 @@
     import cirq
 
 
+@value.value_equality()
 class DepolarizingNoiseModel(devices.NoiseModel):
     """Applies depolarizing noise to each qubit individually at the end of
     every moment.
@@ -39,9 +40,20 @@ def __init__(self, depol_prob: float, prepend: bool = False):
             prepend: If True, put noise before affected gates. Default: False.
         """
         value.validate_probability(depol_prob, 'depol prob')
+        self.depol_prob = depol_prob
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self._prepend = prepend
 
+    def _value_equality_values_(self):
+        return self.depol_prob, self._prepend
+
+    def __repr__(self) -> str:
+        p = self.depol_prob
+        return (
+            f'cirq.contrib.noise_models.DepolarizingNoiseModel('
+            f'{p!r}, prepend={self._prepend!r})'
+        )
+
     def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if validate_all_measurements(moment) or self.is_virtual_moment(moment):  # pragma: no cover
             return moment
@@ -54,7 +66,15 @@ def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         ]
         return output[::-1] if self._prepend else output
 
+    def _json_dict_(self) -> dict[str, object]:
+        return {'depol_prob': self.depol_prob, 'prepend': self._prepend}
+
+    @classmethod
+    def _from_json_dict_(cls, depol_prob, prepend, **kwargs):
+        return cls(depol_prob, prepend=prepend)
 
+
+@value.value_equality()
 class ReadoutNoiseModel(devices.NoiseModel):
     """NoiseModel with probabilistic bit flips preceding measurement.
 
@@ -75,9 +95,17 @@ def __init__(self, bitflip_prob: float, prepend: bool = True):
             prepend: If True, put noise before affected gates. Default: True.
         """
         value.validate_probability(bitflip_prob, 'bitflip prob')
+        self.bitflip_prob = bitflip_prob
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
         self._prepend = prepend
 
+    def _value_equality_values_(self):
+        return self.bitflip_prob, self._prepend
+
+    def __repr__(self) -> str:
+        p = self.bitflip_prob
+        return f'cirq.contrib.noise_models.ReadoutNoiseModel(' f'{p!r}, prepend={self._prepend!r})'
+
     def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if self.is_virtual_moment(moment):
             return moment
@@ -91,7 +119,15 @@ def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
             return output if self._prepend else output[::-1]
         return moment
 
+    def _json_dict_(self) -> dict[str, object]:
+        return {'bitflip_prob': self.bitflip_prob, 'prepend': self._prepend}
+
+    @classmethod
+    def _from_json_dict_(cls, bitflip_prob, prepend, **kwargs):
+        return cls(bitflip_prob, prepend=prepend)
+
 
+@value.value_equality()
 class DampedReadoutNoiseModel(devices.NoiseModel):
     """NoiseModel with T1 decay preceding measurement.
 
@@ -112,9 +148,20 @@ def __init__(self, decay_prob: float, prepend: bool = True):
             prepend: If True, put noise before affected gates. Default: True.
         """
         value.validate_probability(decay_prob, 'decay_prob')
+        self.decay_prob = decay_prob
         self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
         self._prepend = prepend
 
+    def _value_equality_values_(self):
+        return self.decay_prob, self._prepend
+
+    def __repr__(self) -> str:
+        p = self.decay_prob
+        return (
+            f'cirq.contrib.noise_models.DampedReadoutNoiseModel('
+            f'{p!r}, prepend={self._prepend!r})'
+        )
+
     def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if self.is_virtual_moment(moment):
             return moment
@@ -128,7 +175,15 @@ def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
             return output if self._prepend else output[::-1]
         return moment
 
+    def _json_dict_(self) -> dict[str, object]:
+        return {'decay_prob': self.decay_prob, 'prepend': self._prepend}
 
+    @classmethod
+    def _from_json_dict_(cls, decay_prob, prepend, **kwargs):
+        return cls(decay_prob, prepend=prepend)
+
+
+@value.value_equality()
 class DepolarizingWithReadoutNoiseModel(devices.NoiseModel):
     """DepolarizingNoiseModel with probabilistic bit flips preceding
     measurement.
@@ -145,15 +200,33 @@ def __init__(self, depol_prob: float, bitflip_prob: float):
         """
         value.validate_probability(depol_prob, 'depol prob')
         value.validate_probability(bitflip_prob, 'bitflip prob')
+        self.depol_prob = depol_prob
+        self.bitflip_prob = bitflip_prob
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
 
+    def _value_equality_values_(self):
+        return self.depol_prob, self.bitflip_prob
+
+    def __repr__(self) -> str:
+        p = self.depol_prob
+        b = self.bitflip_prob
+        return 'cirq.contrib.noise_models.DepolarizingWithReadoutNoiseModel(' f'{p!r}, {b!r})'
+
     def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if validate_all_measurements(moment):
             return [circuits.Moment(self.readout_noise_gate(q) for q in system_qubits), moment]
         return [moment, circuits.Moment(self.qubit_noise_gate(q) for q in system_qubits)]
 
+    def _json_dict_(self) -> dict[str, object]:
+        return {'depol_prob': self.depol_prob, 'bitflip_prob': self.bitflip_prob}
+
+    @classmethod
+    def _from_json_dict_(cls, depol_prob, bitflip_prob, **kwargs):
+        return cls(depol_prob, bitflip_prob)
 
+
+@value.value_equality()
 class DepolarizingWithDampedReadoutNoiseModel(devices.NoiseModel):
     """DepolarizingWithReadoutNoiseModel with T1 decay preceding
     measurement.
@@ -174,10 +247,25 @@ def __init__(self, depol_prob: float, bitflip_prob: float, decay_prob: float):
         value.validate_probability(depol_prob, 'depol prob')
         value.validate_probability(bitflip_prob, 'bitflip prob')
         value.validate_probability(decay_prob, 'decay_prob')
+        self.depol_prob = depol_prob
+        self.bitflip_prob = bitflip_prob
+        self.decay_prob = decay_prob
         self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
         self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
         self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
 
+    def _value_equality_values_(self):
+        return self.depol_prob, self.bitflip_prob, self.decay_prob
+
+    def __repr__(self) -> str:
+        p = self.depol_prob
+        b = self.bitflip_prob
+        d = self.decay_prob
+        return (
+            'cirq.contrib.noise_models.DepolarizingWithDampedReadoutNoiseModel('
+            f'{p!r}, {b!r}, {d!r})'
+        )
+
     def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
         if validate_all_measurements(moment):
             return [
@@ -187,3 +275,14 @@ def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
             ]
         else:
             return [moment, circuits.Moment(self.qubit_noise_gate(q) for q in system_qubits)]
+
+    def _json_dict_(self) -> dict[str, object]:
+        return {
+            'depol_prob': self.depol_prob,
+            'bitflip_prob': self.bitflip_prob,
+            'decay_prob': self.decay_prob,
+        }
+
+    @classmethod
+    def _from_json_dict_(cls, depol_prob, bitflip_prob, decay_prob, **kwargs):
+        return cls(depol_prob, bitflip_prob, decay_prob)

cirq-core/cirq/contrib/noise_models/noise_models_test.py

@@ -14,6 +14,8 @@
 
 from __future__ import annotations
 
+import pytest
+
 import cirq
 import cirq.contrib.noise_models as ccn
 from cirq import ops
@@ -94,6 +96,22 @@ def test_readout_noise_after_moment() -> None:
     assert_equivalent_op_tree(true_noisy_program, noisy_circuit)
 
 
+@pytest.mark.parametrize(
+    'model',
+    [
+        ccn.DepolarizingNoiseModel(0.1),
+        ccn.ReadoutNoiseModel(0.2),
+        ccn.DampedReadoutNoiseModel(0.3),
+        ccn.DepolarizingWithReadoutNoiseModel(0.1, 0.2),
+        ccn.DepolarizingWithDampedReadoutNoiseModel(0.1, 0.2, 0.3),
+    ],
+)
+def test_repr_and_json_roundtrip(model) -> None:
+    assert model == eval(repr(model))
+    json_text = cirq.to_json(model)
+    assert cirq.read_json(json_text=json_text) == model
+
+
 def test_readout_noise_no_prepend() -> None:
     noise_model = ccn.ReadoutNoiseModel(bitflip_prob=0.005, prepend=False)
     qubits = cirq.LineQubit.range(2)