cirq-core 1.6.0.dev20250721212657__py3-none-any.whl → 1.6.0.dev20250722040433__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 11, 0):  # pragma: no cover
         'of Cirq (e.g. "python -m pip install cirq==1.5.0")'
     )
 
-__version__ = "1.6.0.dev20250721212657"
+__version__ = "1.6.0.dev20250722040433"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version() -> None:
-    assert cirq.__version__ == "1.6.0.dev20250721212657"
+    assert cirq.__version__ == "1.6.0.dev20250722040433"

cirq/contrib/json.py

@@ -3,18 +3,42 @@
 
 from __future__ import annotations
 
-from cirq.protocols.json_serialization import DEFAULT_RESOLVERS, ObjectFactory
+import functools
+
+from cirq.protocols.json_serialization import _register_resolver, DEFAULT_RESOLVERS, ObjectFactory
 
 
 def contrib_class_resolver(cirq_type: str) -> ObjectFactory | None:
     """Extend cirq's JSON API with resolvers for cirq contrib classes."""
+    return _class_resolver_dictionary().get(cirq_type, None)
+
+
+@functools.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/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/contrib/json_test_data/spec.py

@@ -0,0 +1,32 @@
+# 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.
+
+
+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=["Unique", "CircuitDag"],
+    resolver_cache=_class_resolver_dictionary(),
+    deprecated={},
+    # TODO: #7520 - create .json and .repr for these so they can be tested here
+    tested_elsewhere=["QuantumVolumeResult", "SwapPermutationGate", "BayesianNetworkGate"],
+)

cirq/contrib/noise_models/noise_models.py

@@ -23,6 +23,7 @@ if TYPE_CHECKING:
     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,24 @@ class DepolarizingNoiseModel(devices.NoiseModel):
             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
 
+    @property
+    def depol_prob(self):
+        """The depolarizing probability."""
+        return self._depol_prob
+
+    def _value_equality_values_(self):
+        return self.depol_prob, self._prepend
+
+    def __repr__(self) -> str:
+        return (
+            f'cirq.contrib.noise_models.DepolarizingNoiseModel('
+            f'{self.depol_prob!r}, prepend={self._prepend!r})'
+        )
+
     def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if validate_all_measurements(moment) or self.is_virtual_moment(moment):  # pragma: no cover
             return moment
@@ -54,7 +70,11 @@ class DepolarizingNoiseModel(devices.NoiseModel):
         ]
         return output[::-1] if self._prepend else output
 
+    def _json_dict_(self) -> dict[str, object]:
+        return {'depol_prob': self.depol_prob, 'prepend': self._prepend}
 
+
+@value.value_equality()
 class ReadoutNoiseModel(devices.NoiseModel):
     """NoiseModel with probabilistic bit flips preceding measurement.
 
@@ -75,9 +95,22 @@ class ReadoutNoiseModel(devices.NoiseModel):
             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
 
+    @property
+    def bitflip_prob(self):
+        """The probability of a bit-flip during measurement."""
+        return self._bitflip_prob
+
+    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({p!r}, prepend={self._prepend!r})'
+
     def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if self.is_virtual_moment(moment):
             return moment
@@ -91,7 +124,11 @@ class ReadoutNoiseModel(devices.NoiseModel):
             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}
+
 
+@value.value_equality()
 class DampedReadoutNoiseModel(devices.NoiseModel):
     """NoiseModel with T1 decay preceding measurement.
 
@@ -112,9 +149,24 @@ class DampedReadoutNoiseModel(devices.NoiseModel):
             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
 
+    @property
+    def decay_prob(self):
+        """The probability of T1 decay during measurement."""
+        return self._decay_prob
+
+    def _value_equality_values_(self):
+        return self.decay_prob, self._prepend
+
+    def __repr__(self) -> str:
+        return (
+            f'cirq.contrib.noise_models.DampedReadoutNoiseModel('
+            f'{self.decay_prob!r}, prepend={self._prepend!r})'
+        )
+
     def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if self.is_virtual_moment(moment):
             return moment
@@ -128,7 +180,11 @@ class DampedReadoutNoiseModel(devices.NoiseModel):
             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}
+
 
+@value.value_equality()
 class DepolarizingWithReadoutNoiseModel(devices.NoiseModel):
     """DepolarizingNoiseModel with probabilistic bit flips preceding
     measurement.
@@ -145,15 +201,39 @@ class DepolarizingWithReadoutNoiseModel(devices.NoiseModel):
         """
         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)
 
+    @property
+    def depol_prob(self):
+        """The depolarizing probability."""
+        return self._depol_prob
+
+    @property
+    def bitflip_prob(self):
+        """The probability of a bit-flip during measurement."""
+        return self._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 f'cirq.contrib.noise_models.DepolarizingWithReadoutNoiseModel({p!r}, {b!r})'
+
     def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         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}
+
 
+@value.value_equality()
 class DepolarizingWithDampedReadoutNoiseModel(devices.NoiseModel):
     """DepolarizingWithReadoutNoiseModel with T1 decay preceding
     measurement.
@@ -174,10 +254,37 @@ class DepolarizingWithDampedReadoutNoiseModel(devices.NoiseModel):
         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)
 
+    @property
+    def depol_prob(self):
+        """The depolarizing probability."""
+        return self._depol_prob
+
+    @property
+    def bitflip_prob(self):
+        """Probability of a bit-flip during measurement."""
+        return self._bitflip_prob
+
+    @property
+    def decay_prob(self):
+        """The probability of T1 decay during measurement."""
+        return self._decay_prob
+
+    def _value_equality_values_(self):
+        return self.depol_prob, self.bitflip_prob, self.decay_prob
+
+    def __repr__(self) -> str:
+        return (
+            'cirq.contrib.noise_models.DepolarizingWithDampedReadoutNoiseModel('
+            f'{self.depol_prob!r}, {self.bitflip_prob!r}, {self.decay_prob!r})'
+        )
+
     def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if validate_all_measurements(moment):
             return [
@@ -187,3 +294,10 @@ class DepolarizingWithDampedReadoutNoiseModel(devices.NoiseModel):
             ]
         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,
+        }

cirq/contrib/noise_models/noise_models_test.py

@@ -14,10 +14,12 @@
 
 from __future__ import annotations
 
+import pytest
+
 import cirq
 import cirq.contrib.noise_models as ccn
 from cirq import ops
-from cirq.testing import assert_equivalent_op_tree
+from cirq.testing import assert_equivalent_op_tree, assert_equivalent_repr
 
 
 def test_depol_noise() -> None:
@@ -96,6 +98,26 @@ 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.DepolarizingNoiseModel(0.1, prepend=False),
+        ccn.DepolarizingNoiseModel(0.1, prepend=True),
+        ccn.ReadoutNoiseModel(0.2),
+        ccn.ReadoutNoiseModel(0.2, prepend=False),
+        ccn.ReadoutNoiseModel(0.2, prepend=True),
+        ccn.DampedReadoutNoiseModel(0.3),
+        ccn.DampedReadoutNoiseModel(0.3, prepend=False),
+        ccn.DampedReadoutNoiseModel(0.3, prepend=True),
+        ccn.DepolarizingWithReadoutNoiseModel(0.1, 0.2),
+        ccn.DepolarizingWithDampedReadoutNoiseModel(0.1, 0.2, 0.3),
+    ],
+)
+def test_repr(model) -> None:
+    assert_equivalent_repr(model)
+
+
 def test_readout_noise_no_prepend() -> None:
     noise_model = ccn.ReadoutNoiseModel(bitflip_prob=0.005, prepend=False)
     qubits = cirq.LineQubit.range(2)

cirq/devices/noise_properties.py

@@ -24,7 +24,7 @@ from __future__ import annotations
 import abc
 from typing import Iterable, Sequence, TYPE_CHECKING
 
-from cirq import _import, devices, ops, protocols
+from cirq import _import, devices, ops, protocols, value
 from cirq.devices.noise_utils import PHYSICAL_GATE_TAG
 
 circuits = _import.LazyLoader("circuits", globals(), "cirq.circuits.circuit")
@@ -41,6 +41,7 @@ class NoiseProperties(abc.ABC):
         """Construct all NoiseModels associated with this NoiseProperties."""
 
 
+@value.value_equality
 class NoiseModelFromNoiseProperties(devices.NoiseModel):
     def __init__(self, noise_properties: NoiseProperties) -> None:
         """Creates a Noise Model from a NoiseProperties object that can be used with a Simulator.
@@ -54,6 +55,9 @@ class NoiseModelFromNoiseProperties(devices.NoiseModel):
         self._noise_properties = noise_properties
         self.noise_models = self._noise_properties.build_noise_models()
 
+    def _value_equality_values_(self):
+        return self._noise_properties
+
     def is_virtual(self, op: cirq.Operation) -> bool:
         """Returns True if an operation is virtual.
 
@@ -126,3 +130,6 @@ class NoiseModelFromNoiseProperties(devices.NoiseModel):
                 combined_measure_ops.append(multi_measurements[key])
             final_moments.append(circuits.Moment(combined_measure_ops))
         return final_moments
+
+    def _json_dict_(self) -> dict[str, object]:
+        return {'noise_properties': self._noise_properties}

cirq/devices/noise_properties_test.py

@@ -14,14 +14,21 @@
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 import cirq
+import cirq.testing
 from cirq.devices.insertion_noise_model import InsertionNoiseModel
 from cirq.devices.noise_properties import NoiseModelFromNoiseProperties, NoiseProperties
 from cirq.devices.noise_utils import OpIdentifier, PHYSICAL_GATE_TAG
 
+if TYPE_CHECKING:
+    from cirq.protocols.json_serialization import ObjectFactory
+
 
 # These properties are for testing purposes only - they are not representative
 # of device behavior for any existing hardware.
+@cirq.value_equality
 class SampleNoiseProperties(NoiseProperties):
     def __init__(self, system_qubits: list[cirq.Qid], qubit_pairs: list[tuple[cirq.Qid, cirq.Qid]]):
         self.qubits = system_qubits
@@ -34,6 +41,16 @@ class SampleNoiseProperties(NoiseProperties):
         )
         return [add_h, add_iswap]
 
+    def _value_equality_values_(self):
+        return (self.qubits, self.qubit_pairs)
+
+    def _json_dict_(self) -> dict[str, object]:
+        return {'system_qubits': self.qubits, 'qubit_pairs': self.qubit_pairs}
+
+    @classmethod
+    def _from_json_dict_(cls, system_qubits, qubit_pairs, **kwargs):
+        return cls(system_qubits=system_qubits, qubit_pairs=[tuple(pair) for pair in qubit_pairs])
+
 
 def test_sample_model() -> None:
     q0, q1 = cirq.LineQubit.range(2)
@@ -54,3 +71,17 @@ def test_sample_model() -> None:
         cirq.Moment(cirq.H(q0), cirq.H(q1)),
     )
     assert noisy_circuit == expected_circuit
+
+
+def custom_resolver(cirq_type: str) -> ObjectFactory | None:
+    if cirq_type == "SampleNoiseProperties":
+        return SampleNoiseProperties
+    return None
+
+
+def test_noise_model_from_noise_properties_json() -> None:
+    q0, q1 = cirq.LineQubit.range(2)
+    props = SampleNoiseProperties([q0, q1], [(q0, q1), (q1, q0)])
+    model = NoiseModelFromNoiseProperties(props)
+    resolvers = [custom_resolver] + cirq.DEFAULT_RESOLVERS
+    cirq.testing.assert_json_roundtrip_works(model, resolvers=resolvers)

cirq/devices/thermal_noise_model.py

@@ -14,14 +14,14 @@
 
 from __future__ import annotations
 
-import dataclasses
 import functools
 from typing import Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
 
-from cirq import devices, ops, protocols, qis
+from cirq import devices, ops, protocols, qis, value
+from cirq._compat import proper_repr
 from cirq._import import LazyLoader
 from cirq.devices.noise_utils import PHYSICAL_GATE_TAG
 
@@ -130,19 +130,16 @@ def _decoherence_matrix(
     return rate_matrix
 
 
-def _as_rate_dict(
-    rate_or_dict: float | dict[cirq.Qid, float] | None, qubits: set[cirq.Qid]
-) -> dict[cirq.Qid, float]:
-    """Convert float or None input into dictionary form.
-
-    This method also ensures that no qubits are missing from dictionary keys.
-    """
+def _get_rate_for_qubit(
+    rate_or_dict: float | dict[cirq.Qid, float] | None, qubit: cirq.Qid
+) -> float:
+    """Convert supported rate specification values in ThermalNoiseModel to a float."""
     if rate_or_dict is None:
-        return {q: 0.0 for q in qubits}
+        return 0.0
     elif isinstance(rate_or_dict, dict):
-        return {**{q: 0.0 for q in qubits}, **rate_or_dict}
+        return rate_or_dict.get(qubit, 0.0)
     else:
-        return {q: rate_or_dict for q in qubits}
+        return rate_or_dict
 
 
 def _validate_rates(qubits: set[cirq.Qid], rates: dict[cirq.Qid, np.ndarray]) -> None:
@@ -160,7 +157,7 @@ def _validate_rates(qubits: set[cirq.Qid], rates: dict[cirq.Qid, np.ndarray]) ->
             )
 
 
-@dataclasses.dataclass
+@value.value_equality
 class ThermalNoiseModel(devices.NoiseModel):
     """NoiseModel representing simulated thermalization of a qubit.
 
@@ -214,24 +211,55 @@ class ThermalNoiseModel(devices.NoiseModel):
         """
         rate_dict = {}
 
-        heat_rate_GHz = _as_rate_dict(heat_rate_GHz, qubits)
-        cool_rate_GHz = _as_rate_dict(cool_rate_GHz, qubits)
-        dephase_rate_GHz = _as_rate_dict(dephase_rate_GHz, qubits)
-
-        for q in qubits:
-            gamma_h = heat_rate_GHz[q]
-            gamma_c = cool_rate_GHz[q]
-            gamma_phi = dephase_rate_GHz[q]
-
+        # let us have reproducible sorted order in the rate_matrix_GHz dictionary
+        for q in sorted(qubits):
+            gamma_h = _get_rate_for_qubit(heat_rate_GHz, q)
+            gamma_c = _get_rate_for_qubit(cool_rate_GHz, q)
+            gamma_phi = _get_rate_for_qubit(dephase_rate_GHz, q)
             rate_dict[q] = _decoherence_matrix(gamma_c, gamma_phi, gamma_h, q.dimension)
 
         _validate_rates(qubits, rate_dict)
         self.gate_durations_ns: dict[type, float] = gate_durations_ns
         self.rate_matrix_GHz: dict[cirq.Qid, np.ndarray] = rate_dict
+        self._heat_rate_GHz = heat_rate_GHz
+        self._cool_rate_GHz = cool_rate_GHz
+        self._dephase_rate_GHz = dephase_rate_GHz
         self.require_physical_tag: bool = require_physical_tag
         self.skip_measurements: bool = skip_measurements
         self._prepend = prepend
 
+    def _value_equality_values_(self):
+        gate_durations_ns_tuple = tuple(
+            sorted(self.gate_durations_ns.items(), key=lambda x: str(x[0]))
+        )
+        rate_matrix_GHz_tuple = tuple(
+            sorted((q, tuple(m.flat)) for q, m in self.rate_matrix_GHz.items())
+        )
+        return (
+            gate_durations_ns_tuple,
+            rate_matrix_GHz_tuple,
+            self.require_physical_tag,
+            self.skip_measurements,
+            self._prepend,
+        )
+
+    def __repr__(self) -> str:
+        rate_args_repr = []
+        if self._heat_rate_GHz is not None:
+            rate_args_repr.append(f"heat_rate_GHz={proper_repr(self._heat_rate_GHz)}, ")
+        if self._cool_rate_GHz is not None:
+            rate_args_repr.append(f"cool_rate_GHz={proper_repr(self._cool_rate_GHz)}, ")
+        if self._dephase_rate_GHz is not None:
+            rate_args_repr.append(f"dephase_rate_GHz={proper_repr(self._dephase_rate_GHz)}, ")
+        return (
+            "cirq.devices.ThermalNoiseModel("
+            f"qubits={set(self.rate_matrix_GHz.keys())!r}, "
+            f"gate_durations_ns={proper_repr(self.gate_durations_ns)}, "
+            f"{''.join(rate_args_repr)}"
+            f"require_physical_tag={self.require_physical_tag!r}, "
+            f"skip_measurements={self.skip_measurements!r}, prepend={self._prepend!r})"
+        )
+
     def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if not moment.operations:
             return [moment]
@@ -283,3 +311,45 @@ class ThermalNoiseModel(devices.NoiseModel):
             return [moment]
         output = [moment, moment_module.Moment(noise_ops)]
         return output[::-1] if self._prepend else output
+
+    def _json_dict_(self) -> dict[str, object]:
+        qubits = sorted(self.rate_matrix_GHz.keys())
+
+        return {
+            'qubits': qubits,
+            'gate_durations_ns': {
+                protocols.json_cirq_type(k): v for k, v in self.gate_durations_ns.items()
+            },
+            'heat_rate_GHz': [_get_rate_for_qubit(self._heat_rate_GHz, q) for q in qubits],
+            'cool_rate_GHz': [_get_rate_for_qubit(self._cool_rate_GHz, q) for q in qubits],
+            'dephase_rate_GHz': [_get_rate_for_qubit(self._dephase_rate_GHz, q) for q in qubits],
+            'require_physical_tag': self.require_physical_tag,
+            'skip_measurements': self.skip_measurements,
+            'prepend': self._prepend,
+        }
+
+    @classmethod
+    def _from_json_dict_(
+        cls,
+        qubits,
+        gate_durations_ns,
+        heat_rate_GHz,
+        cool_rate_GHz,
+        dephase_rate_GHz,
+        require_physical_tag,
+        skip_measurements,
+        prepend,
+        **kwargs,
+    ):
+        return cls(
+            qubits=set(qubits),
+            gate_durations_ns={
+                protocols.cirq_type_from_json(k): v for k, v in gate_durations_ns.items()
+            },
+            heat_rate_GHz=dict(zip(qubits, heat_rate_GHz)),
+            cool_rate_GHz=dict(zip(qubits, cool_rate_GHz)),
+            dephase_rate_GHz=dict(zip(qubits, dephase_rate_GHz)),
+            require_physical_tag=require_physical_tag,
+            skip_measurements=skip_measurements,
+            prepend=prepend,
+        )

cirq/devices/thermal_noise_model_test.py

@@ -342,3 +342,22 @@ def test_noisy_moment_two_qubit():
             [9.87330937e-01, 0, 0, 9.95013725e-01],
         ],
     )
+
+
+def test_repr():
+    q0 = cirq.LineQubit(0)
+    model = ThermalNoiseModel(
+        qubits={q0},
+        gate_durations_ns={cirq.ZPowGate: 5.0},
+        heat_rate_GHz={q0: 1e-5},
+        cool_rate_GHz={q0: 1e-4},
+        dephase_rate_GHz={q0: 2e-4},
+        require_physical_tag=False,
+        skip_measurements=False,
+    )
+    cirq.testing.assert_equivalent_repr(model)
+    # optional rate arguments are skipped when unspecified
+    s1 = repr(ThermalNoiseModel(qubits={q0}, gate_durations_ns={cirq.ZPowGate: 5.0}))
+    assert 'heat_rate_GHz' not in s1
+    assert 'cool_rate_GHz' not in s1
+    assert 'dephase_rate_GHz' not in s1

cirq/json_resolver_cache.py

@@ -48,7 +48,7 @@ def _class_resolver_dictionary() -> dict[str, ObjectFactory]:
     import pandas as pd
 
     import cirq
-    from cirq.devices import InsertionNoiseModel
+    from cirq.devices import InsertionNoiseModel, NoiseModelFromNoiseProperties, ThermalNoiseModel
     from cirq.devices.noise_model import _NoNoiseModel
     from cirq.experiments import GridInteractionLayer
     from cirq.ops import raw_types
@@ -175,6 +175,7 @@ def _class_resolver_dictionary() -> dict[str, ObjectFactory]:
         'NamedQubit': cirq.NamedQubit,
         'NamedQid': cirq.NamedQid,
         'NoIdentifierQubit': cirq.testing.NoIdentifierQubit,
+        'NoiseModelFromNoiseProperties': NoiseModelFromNoiseProperties,
         'ObservableMeasuredResult': cirq.work.ObservableMeasuredResult,
         'OpIdentifier': cirq.OpIdentifier,
         'ParamResolver': cirq.ParamResolver,
@@ -226,6 +227,7 @@ def _class_resolver_dictionary() -> dict[str, ObjectFactory]:
         'SympyCondition': cirq.SympyCondition,
         'TaggedOperation': cirq.TaggedOperation,
         'TensoredConfusionMatrices': cirq.TensoredConfusionMatrices,
+        'ThermalNoiseModel': ThermalNoiseModel,
         'TiltedSquareLattice': cirq.TiltedSquareLattice,
         'ThreeQubitDiagonalGate': cirq.ThreeQubitDiagonalGate,
         'TrialResult': cirq.ResultDict,  # keep support for Cirq < 0.11.

cirq/protocols/json_serialization_test.py

@@ -52,6 +52,7 @@ TESTED_MODULES: dict[str, _ModuleDeprecation | None] = {
     'cirq_ionq': None,
     'cirq_google': None,
     'cirq_pasqal': None,
+    f'cirq{"."}contrib': None,
     'cirq.protocols': None,
     'non_existent_should_be_fine': None,
 }

cirq/protocols/json_test_data/ThermalNoiseModel.json

@@ -0,0 +1,32 @@
+{
+  "cirq_type": "ThermalNoiseModel",
+  "qubits": [
+    {
+      "cirq_type": "LineQubit",
+      "x": 0
+    },
+    {
+      "cirq_type": "LineQubit",
+      "x": 1
+    }
+  ],
+  "gate_durations_ns": {
+    "ZPowGate": 5.0,
+    "CZPowGate": 12.0
+  },
+  "heat_rate_GHz": [
+    1e-05,
+    1e-05
+  ],
+  "cool_rate_GHz": [
+    0.0001,
+    0.00015
+  ],
+  "dephase_rate_GHz": [
+    0.0002,
+    0.0002
+  ],
+  "require_physical_tag": false,
+  "skip_measurements": false,
+  "prepend": false
+}

cirq/protocols/json_test_data/ThermalNoiseModel.repr

@@ -0,0 +1 @@
+cirq.devices.ThermalNoiseModel(qubits={cirq.LineQubit(0), cirq.LineQubit(1)}, gate_durations_ns={cirq.ops.common_gates.ZPowGate: 5.0,cirq.ops.common_gates.CZPowGate: 12.0}, heat_rate_GHz=1e-05, cool_rate_GHz={cirq.LineQubit(0): 0.0001,cirq.LineQubit(1): 0.00015}, dephase_rate_GHz=0.0002, require_physical_tag=False, skip_measurements=False, prepend=False)

cirq/protocols/json_test_data/spec.py

@@ -166,15 +166,17 @@ TestSpec = ModuleJsonTestSpec(
         'ParamMappingType',
         # utility:
         'CliffordSimulator',
-        'NoiseModelFromNoiseProperties',
         'Simulator',
         'StabilizerSampler',
         'DEFAULT_RESOLVERS',
     ],
     deprecated={},
     tested_elsewhere=[
+        # Tested in cirq.devices.noise_properties_test module, because
+        # serde test uses a non-public SampleNoiseProperties class.
+        'NoiseModelFromNoiseProperties',
         # SerializableByKey does not follow common serialization rules.
         # It is tested separately in test_context_serialization.
-        'SerializableByKey'
+        'SerializableByKey',
     ],
 )

{cirq_core-1.6.0.dev20250721212657.dist-info → cirq_core-1.6.0.dev20250722040433.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cirq-core
-Version: 1.6.0.dev20250721212657
+Version: 1.6.0.dev20250722040433
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers

{cirq_core-1.6.0.dev20250721212657.dist-info → cirq_core-1.6.0.dev20250722040433.dist-info}/RECORD

@@ -4,10 +4,10 @@ cirq/_compat_test.py,sha256=emXpdD5ZvwLRlFAoQB8YatmZyU3b4e9jg6FppMTUhkU,33900
 cirq/_doc.py,sha256=BrnoABo1hk5RgB3Cgww4zLHUfiyFny0F1V-tOMCbdaU,2909
 cirq/_import.py,sha256=ixBu4EyGl46Ram2cP3p5eZVEFDW5L2DS-VyTjz4N9iw,8429
 cirq/_import_test.py,sha256=oF4izzOVZLc7NZ0aZHFcGv-r01eiFFt_JORx_x7_D4s,1089
-cirq/_version.py,sha256=oKI_Ebte66Mc7O62NRWMD5tC6qXWK7rEMmfUCmDrkXo,1206
-cirq/_version_test.py,sha256=5kidWwva2m6D_V7MWpMSxAcfnDgKKmXQy-R2nrbrO5A,155
+cirq/_version.py,sha256=plnCZFSbWJaIamttoW4NByhOoJdhoCyrqJEHKJ37hwA,1206
+cirq/_version_test.py,sha256=9KAtcFqzeXTp7mlnfEO0YP55nBQ6N8eUQq55_wFsgjg,155
 cirq/conftest.py,sha256=wSDKNdIQRDfLnXvOCWD3erheOw8JHRhdfQ53EyTUIXg,1239
-cirq/json_resolver_cache.py,sha256=hYyG53VJeV61X0oukK5ndZYega8lkL2FyaL1m0j6h5M,13556
+cirq/json_resolver_cache.py,sha256=A5DIgFAY1hUNt9vai_C3-gGBv24116CJMzQxMcXOax4,13726
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
 cirq/circuits/__init__.py,sha256=HKunqRpZoDmjy1IiK9Cn84MTGT84_PMeQ5VDCPafcWk,1335
 cirq/circuits/_block_diagram_drawer.py,sha256=OpIupxl6plGVaLkU13RqYGELAlHAIy56tV6qjg51Yws,9489
@@ -33,7 +33,7 @@ cirq/circuits/qasm_output_test.py,sha256=e2TsMMVZLzyCYh6U3umPtusxmeiLJDunmsgFRa5
 cirq/circuits/text_diagram_drawer.py,sha256=G2fJcoyUP0ikrhTluFo4lULCEXKJI0dai5lBtHm0f14,16485
 cirq/circuits/text_diagram_drawer_test.py,sha256=YBe8zT7BDENoR-gA3l77mtRj6vxY3kVVZ4FqBO_WwsY,11031
 cirq/contrib/__init__.py,sha256=DSA8bHVvPSivnEtLS2WmAa89pzGxK8u2MyMHwpJ3HSM,1121
-cirq/contrib/json.py,sha256=U7mSvxAITKkeXVqN3hCyTVGM2Mzb2chxdU3tXp6Q0c8,827
+cirq/contrib/json.py,sha256=7qE7iFEH5jWII3ZaIHjnitt3k-MULDxZ-0TFIQ4nJSQ,1473
 cirq/contrib/json_test.py,sha256=9wJb-N1Sv_Epz548el6g6iZYB5VgPk2eOBHYur0V0ho,1178
 cirq/contrib/acquaintance/__init__.py,sha256=hIRO807ywD3L5xwIPROAOq5FFnel9uXcQCw1uYBlNhg,3215
 cirq/contrib/acquaintance/bipartite.py,sha256=9BusD-thMIfOEZeDuUEBnZUJoOJ8bc-DzNJTVMOrVR8,6494
@@ -84,9 +84,11 @@ cirq/contrib/graph_device/uniform_graph_device_test.py,sha256=M7cxp4UEbhTf-kdVUc
 cirq/contrib/hacks/__init__.py,sha256=C1uZ1J79EG0dmPxj29mnjdfx6aRU6moz6QAD9PFGUYM,584
 cirq/contrib/hacks/disable_validation.py,sha256=cOqo4QUtbDu1PAOUCQRjT8EKE_AImbQr2rwGi0AOO0k,1530
 cirq/contrib/hacks/disable_validation_test.py,sha256=sz319WQwkSvkAUr913lhlrh1NM7-ozMffb3MxCjbwgY,1755
+cirq/contrib/json_test_data/__init__.py,sha256=y4pe0VWiQAa4PmWikB3XKFVgiuJWspUzW9ugDUYq8C8,723
+cirq/contrib/json_test_data/spec.py,sha256=9Q_-qZkFM6S0bMFzyt-Bv2lPrHaUxltPmYCsn-wTxrs,1182
 cirq/contrib/noise_models/__init__.py,sha256=O3wvaQ6kyNZzwsCnMMZvr2EyS76LpO9xnVZ69a2obv0,957
-cirq/contrib/noise_models/noise_models.py,sha256=3uiZh9xXSr_Q29vHnJlMRBiYdgwd2kyAfXD74Tt2pP4,7754
-cirq/contrib/noise_models/noise_models_test.py,sha256=LRYFQx_-zHb205RnlVKSnpSZOx_KG6Me7_5sW-_S9m8,10744
+cirq/contrib/noise_models/noise_models.py,sha256=roHyBEIvD-WqjOhY8bRi5nzz0lycp3Ny19mr6W0zWsU,11332
+cirq/contrib/noise_models/noise_models_test.py,sha256=htDTYcWeMtgtLIo_4DaTIidoHCxPMVIAKtS80R4OmDs,11472
 cirq/contrib/paulistring/__init__.py,sha256=1k2_MYLTMPn8AFoJvSgpN-F-6xgmDjKXRhb-FdDsFoQ,1761
 cirq/contrib/paulistring/clifford_optimize.py,sha256=VMdivMpQnPQhgqtasce6dOPGx6x6eIZ6Z4f1H666j-I,7859
 cirq/contrib/paulistring/clifford_optimize_test.py,sha256=8FFLg9gb1HmHHMdXPa-vCr1zyxvgdlciRH8qyfTWQRw,3964
@@ -170,14 +172,14 @@ cirq/devices/named_topologies.py,sha256=CNoMG2xhisUgssSdngzr8VpA5YBPjpVhw4dtXxKA
 cirq/devices/named_topologies_test.py,sha256=opABh1NgkfubHF4sCCTAxmFHLZXVZIgdKrZLQefd-AE,4854
 cirq/devices/noise_model.py,sha256=teJNj25_tLTu_8_6fkKNyFAVnaRH6actJFXbhIJCHMY,11239
 cirq/devices/noise_model_test.py,sha256=0kLY4lksbfBz1pAuSXQWBw8xSnwVrfXqlxrUbsaUuUg,9412
-cirq/devices/noise_properties.py,sha256=g6Joc444K4WRwAYQGGP_rIah0nIxxJQ3WJmE8JsgbXo,5105
-cirq/devices/noise_properties_test.py,sha256=UU3JXgDEckm-XTVeEW-LoonrJbst7qw4ahAH42n_cYY,2353
+cirq/devices/noise_properties.py,sha256=pXsTxgj2J6RcJ1uWUYdczUTBMn6ThtvucijNEgbrzQg,5321
+cirq/devices/noise_properties_test.py,sha256=0g0_UP70FE0mU-SySOu-MX6jnuR7XH0Y0QOjZMO8HqA,3418
 cirq/devices/noise_utils.py,sha256=73B1o22072RhsNdo7_t_A-pa7Sub62ff4VpvNt0Ewdk,7155
 cirq/devices/noise_utils_test.py,sha256=Pn_BO0c5Ky9FJk384FXh_BkXXYe1V7GWIBgxsaoB9as,2099
 cirq/devices/superconducting_qubits_noise_properties.py,sha256=pQYEs6KupGW1lOQ5Tt8CEI0vdJ3sh94uTrVZHXosRmk,8142
 cirq/devices/superconducting_qubits_noise_properties_test.py,sha256=Ld7ft0Vr4V69egdL67WKAdDF6vNXc2-SLPzx0u2ph2E,12200
-cirq/devices/thermal_noise_model.py,sha256=LIGlA6ikYWqbh-759RqXPMDMpCV2uKHT_pRLfMCGkYM,11535
-cirq/devices/thermal_noise_model_test.py,sha256=vgloNkmkNes_pn0D50-LD2RUcsMJey7EN8Wm6Nc-d5U,12282
+cirq/devices/thermal_noise_model.py,sha256=TSOKMP1GSVS2FVzFGGt6_Rqd-0Dx4tnvMv6Yf_1YTk0,14426
+cirq/devices/thermal_noise_model_test.py,sha256=F4PtsTxhM-FyA1E_VDgg7e3TjuKeN7sGCdvHi31RxWk,12914
 cirq/devices/unconstrained_device.py,sha256=wa94uVzaCPb1jmG3h6hSGJQggSuCvEK8wekkGXCOx_Q,1551
 cirq/devices/unconstrained_device_test.py,sha256=J8vABVWWywQuX6Jlo5Y0pWTh6VZRatdmjdBL6u0kZKk,1083
 cirq/experiments/__init__.py,sha256=3y8FX6Edh_mEFJ7AWjhDurnSLxuEt0_edqL7CitCrTQ,3777
@@ -411,7 +413,7 @@ cirq/protocols/hash_from_pickle_test.py,sha256=H1V2cy-gtbKhhewZPSI7kcNqgpkS5luF7
 cirq/protocols/inverse_protocol.py,sha256=tHaY8-dfd0SD59v3DZ_zpwz7lwFrraPExEnIgn1T0RI,3965
 cirq/protocols/inverse_protocol_test.py,sha256=5RoZfSRzBvpGpLdg1XKYdB6qy-GkDvZsATUvxdFrLJ0,2067
 cirq/protocols/json_serialization.py,sha256=z7Yu2vsNabRkdeYyIuNCoXATHkrOGreTRShNyN0Fjuc,24520
-cirq/protocols/json_serialization_test.py,sha256=bQELcU7hZ55rBk-sqxwsiotTOId4EWpUztsD6rwqb1g,27841
+cirq/protocols/json_serialization_test.py,sha256=An57W8eBWaUF4kKOCos2UlHzNiILnUJvqmZLmwZ_6MA,27872
 cirq/protocols/kraus_protocol.py,sha256=ptiRkEnDgBnEdxobs6wZdZsOAhVzF6bhhSHuNqLKFJo,9250
 cirq/protocols/kraus_protocol_test.py,sha256=51eJ3r3Kx10rG-1hPjcfcODeUO3PFQmwU9ATMnhTWDw,5495
 cirq/protocols/measurement_key_protocol.py,sha256=JU7XbZfR7o6Wcv5qRJisp3ZAWwW9Fx7OHtxNMrWtZoQ,13351
@@ -769,6 +771,8 @@ cirq/protocols/json_test_data/TaggedOperation.json,sha256=aAOHhS4FRqMMoWW6gBXt94
 cirq/protocols/json_test_data/TaggedOperation.repr,sha256=gTNiZlRQ2MVpAVsJTmvIZ1cyMDZQWe0KuP8mf97D0LE,85
 cirq/protocols/json_test_data/TensoredConfusionMatrices.json,sha256=Irb4yYzbuvaraH4VI0geh5FM1G7ieEkt0msF9XY3QbY,828
 cirq/protocols/json_test_data/TensoredConfusionMatrices.repr,sha256=UnEJkd9BUy501X3zY3UDdXkn-Aj8ZT76qh4YcBOEPMI,535
+cirq/protocols/json_test_data/ThermalNoiseModel.json,sha256=3Pe4purDYGL-rVC1VjM3QKew1qUKOVDDVgqJJPL-b3E,478
+cirq/protocols/json_test_data/ThermalNoiseModel.repr,sha256=q6n8SxiVO4V2PCv8HsE3WVN2RhfXOdST7zaDbt1vxeo,357
 cirq/protocols/json_test_data/ThreeQubitDiagonalGate.json,sha256=Giy1bSDyP88AxpvTuHUIf_ikXhO2XpDLO6XZs2SxrZk,147
 cirq/protocols/json_test_data/ThreeQubitDiagonalGate.repr,sha256=pBPE3IfuWgPtebLWcqpTguUrZ--j-hS1PDTTC7KB1hI,90
 cirq/protocols/json_test_data/TiltedSquareLattice.json,sha256=A7hGSskEasyAu-o3PBsRlFzFrRgpPOuuaFRNGns08F8,69
@@ -858,7 +862,7 @@ cirq/protocols/json_test_data/pandas.Index.json_inward,sha256=KENE3PlSxmtMdnikuJ
 cirq/protocols/json_test_data/pandas.Index.repr_inward,sha256=2YnQUO58RGFGvuVjmR57v25YIvPAnTgVYh0jeQYhXHo,52
 cirq/protocols/json_test_data/pandas.MultiIndex.json,sha256=pF6YdRE3Qjhsf8CeGEZQvX5AWHAWaMNQF6c661Sqrxg,233
 cirq/protocols/json_test_data/pandas.MultiIndex.repr,sha256=g4q-1zFWYG8T7IAI0anQ5aMHSFlGF2CJsAoYdZzbGa8,80
-cirq/protocols/json_test_data/spec.py,sha256=DPG_98SJgYX2VZRNKGjm3EOiSppYpKbKIOBebVj1Elw,5651
+cirq/protocols/json_test_data/spec.py,sha256=qy_Wy5gf96KNz23jwcfJ8wtynnXNP0WbIcC6qS-_5BY,5791
 cirq/protocols/json_test_data/sympy.Add.json,sha256=fVilRXllnMRnQcXuoU06IlwZOWK9Kwim1t6Q_s6z97g,1000
 cirq/protocols/json_test_data/sympy.Add.repr,sha256=9L_05ZlcrFpo8QoExFAAO_kEEpc7SSqGyp0vudkRlsU,228
 cirq/protocols/json_test_data/sympy.And.json,sha256=eaM07ihBPjZbn44gRIy6TbXeEwblF-QN32Jb1ATAQ5Q,178
@@ -1220,8 +1224,8 @@ cirq/work/sampler.py,sha256=rxbMWvrhu3gfNSBjZKozw28lLKVvBAS_1EGyPdYe8Xg,19041
 cirq/work/sampler_test.py,sha256=SsMrRvLDYELyOAWLKISjkdEfrBwLYWRsT6D8WrsLM3Q,13533
 cirq/work/zeros_sampler.py,sha256=Fs2JWwq0n9zv7_G5Rm-9vPeHUag7uctcMOHg0JTkZpc,2371
 cirq/work/zeros_sampler_test.py,sha256=lQLgQDGBLtfImryys2HzQ2jOSGxHgc7-koVBUhv8qYk,3345
-cirq_core-1.6.0.dev20250721212657.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.6.0.dev20250721212657.dist-info/METADATA,sha256=oAZ_OK9p7g-zY3Hy0efUTJ_KxvJC25qgMoSDg--kJzA,4857
-cirq_core-1.6.0.dev20250721212657.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cirq_core-1.6.0.dev20250721212657.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.6.0.dev20250721212657.dist-info/RECORD,,
+cirq_core-1.6.0.dev20250722040433.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.6.0.dev20250722040433.dist-info/METADATA,sha256=4x1la6647P0LD6kFxQCVBGV7dFeZ7Hg-WsDL_qv612k,4857
+cirq_core-1.6.0.dev20250722040433.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cirq_core-1.6.0.dev20250722040433.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.6.0.dev20250722040433.dist-info/RECORD,,