cirq-core 1.5.0.dev20250409222543__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/devices/thermal_noise_model.py

@@ -12,14 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import dataclasses
+from __future__ import annotations
+
 import functools
-from typing import Dict, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
+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
 
@@ -79,7 +81,7 @@ def _lindbladian(left_op: np.ndarray) -> np.ndarray:
 
 @functools.lru_cache(maxsize=256)
 def _kraus_ops_from_rates(
-    flat_rates: Tuple[float, ...], shape: Tuple[int, int]
+    flat_rates: tuple[float, ...], shape: tuple[int, int]
 ) -> Sequence[np.ndarray]:
     """Generate kraus operators from an array of rates.
 
@@ -128,22 +130,19 @@ def _decoherence_matrix(
     return rate_matrix
 
 
-def _as_rate_dict(
-    rate_or_dict: Optional[Union[float, Dict['cirq.Qid', float]]], 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:
+def _validate_rates(qubits: set[cirq.Qid], rates: dict[cirq.Qid, np.ndarray]) -> None:
     """Check all rate matrices are square and of appropriate dimension.
 
     We check rates are positive in the class validator.
@@ -158,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.
 
@@ -169,11 +168,11 @@ class ThermalNoiseModel(devices.NoiseModel):
 
     def __init__(
         self,
-        qubits: Set['cirq.Qid'],
-        gate_durations_ns: Dict[type, float],
-        heat_rate_GHz: Union[float, Dict['cirq.Qid', float], None] = None,
-        cool_rate_GHz: Union[float, Dict['cirq.Qid', float], None] = None,
-        dephase_rate_GHz: Union[float, Dict['cirq.Qid', float], None] = None,
+        qubits: set[cirq.Qid],
+        gate_durations_ns: dict[type, float],
+        heat_rate_GHz: float | dict[cirq.Qid, float] | None = None,
+        cool_rate_GHz: float | dict[cirq.Qid, float] | None = None,
+        dephase_rate_GHz: float | dict[cirq.Qid, float] | None = None,
         require_physical_tag: bool = True,
         skip_measurements: bool = True,
         prepend: bool = False,
@@ -212,27 +211,56 @@ 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.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 noisy_moment(
-        self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']
-    ) -> 'cirq.OP_TREE':
+    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]
         if self.require_physical_tag:
@@ -247,13 +275,13 @@ class ThermalNoiseModel(devices.NoiseModel):
                 # Only moments with physical operations should have noise.
                 return [moment]
 
-        noise_ops: List['cirq.Operation'] = []
+        noise_ops: list[cirq.Operation] = []
         # Some devices (including Google hardware) require that all gates have
         # the same duration, but this does not. Instead, each moment is assumed
         # to be as long as the longest gate it contains.
         moment_ns: float = 0
         for op in moment:
-            op_duration: Optional[float] = None
+            op_duration: float | None = None
             for key, duration in self.gate_durations_ns.items():
                 if not issubclass(type(op.gate), key):
                     continue  # gate type doesn't match
@@ -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

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 import sympy
@@ -340,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/devices/unconstrained_device.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Any, TYPE_CHECKING
 
 from cirq import protocols, value
 from cirq._doc import document
@@ -26,7 +28,7 @@ if TYPE_CHECKING:
 class _UnconstrainedDevice(device.Device):
     """A device that allows everything, infinitely fast."""
 
-    def duration_of(self, operation: 'cirq.Operation') -> 'cirq.Duration':
+    def duration_of(self, operation: cirq.Operation) -> cirq.Duration:
         return value.Duration(picos=0)
 
     def validate_moment(self, moment) -> None:
@@ -41,7 +43,7 @@ class _UnconstrainedDevice(device.Device):
     def _value_equality_values_(self) -> Any:
         return ()
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, [])
 
 

cirq/devices/unconstrained_device_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 
 

cirq/experiments/__init__.py

@@ -15,12 +15,15 @@
 
 from cirq.experiments.qubit_characterizations import (
     RandomizedBenchMarkResult as RandomizedBenchMarkResult,
+    RBParameters as RBParameters,
     single_qubit_randomized_benchmarking as single_qubit_randomized_benchmarking,
+    single_qubit_rb as single_qubit_rb,
     single_qubit_state_tomography as single_qubit_state_tomography,
     TomographyResult as TomographyResult,
     two_qubit_randomized_benchmarking as two_qubit_randomized_benchmarking,
     two_qubit_state_tomography as two_qubit_state_tomography,
     parallel_single_qubit_randomized_benchmarking as parallel_single_qubit_randomized_benchmarking,
+    parallel_single_qubit_rb as parallel_single_qubit_rb,
 )
 
 from cirq.experiments.fidelity_estimation import (
@@ -37,12 +40,11 @@ from cirq.experiments.purity_estimation import (
 )
 
 from cirq.experiments.random_quantum_circuit_generation import (
-    # pylint: disable=line-too-long
     GRID_ALIGNED_PATTERN as GRID_ALIGNED_PATTERN,
     GRID_STAGGERED_PATTERN as GRID_STAGGERED_PATTERN,
     HALF_GRID_STAGGERED_PATTERN as HALF_GRID_STAGGERED_PATTERN,
     GridInteractionLayer as GridInteractionLayer,
-    random_rotations_between_grid_interaction_layers_circuit as random_rotations_between_grid_interaction_layers_circuit,
+    random_rotations_between_grid_interaction_layers_circuit as random_rotations_between_grid_interaction_layers_circuit,  # noqa: E501
 )
 
 from cirq.experiments.readout_confusion_matrix import (

cirq/experiments/benchmarking/__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.
+
+"""Tools for branchmarking NISQ circuits."""
+
+from cirq.experiments.benchmarking.parallel_xeb import parallel_two_qubit_xeb  # noqa: F401