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

cirq/devices/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
+
 from typing import Sequence
 
 import numpy as np
@@ -23,13 +25,15 @@ from cirq.devices.noise_model import validate_all_measurements
 from cirq.testing import assert_equivalent_op_tree
 
 
-def assert_equivalent_op_tree_sequence(x: Sequence[cirq.OP_TREE], y: Sequence[cirq.OP_TREE]):
+def assert_equivalent_op_tree_sequence(
+    x: Sequence[cirq.OP_TREE], y: Sequence[cirq.OP_TREE]
+) -> None:
     assert len(x) == len(y)
     for a, b in zip(x, y):
         assert_equivalent_op_tree(a, b)
 
 
-def test_requires_one_override():
+def test_requires_one_override() -> None:
     class C(cirq.NoiseModel):
         pass
 
@@ -37,7 +41,7 @@ def test_requires_one_override():
         _ = C()
 
 
-def test_infers_other_methods():
+def test_infers_other_methods() -> None:
     q = cirq.LineQubit(0)
 
     class NoiseModelWithNoisyMomentListMethod(cirq.NoiseModel):
@@ -77,7 +81,7 @@ def test_infers_other_methods():
     )
 
     class NoiseModelWithNoisyOperationMethod(cirq.NoiseModel):
-        def noisy_operation(self, operation: 'cirq.Operation'):
+        def noisy_operation(self, operation: cirq.Operation):
             return cirq.Z(operation.qubits[0]).with_tags(ops.VirtualTag())
 
     c = NoiseModelWithNoisyOperationMethod()
@@ -91,7 +95,7 @@ def test_infers_other_methods():
     )
 
 
-def test_no_noise():
+def test_no_noise() -> None:
     q = cirq.LineQubit(0)
     m = cirq.Moment([cirq.X(q)])
     assert cirq.NO_NOISE.noisy_operation(cirq.X(q)) == cirq.X(q)
@@ -102,7 +106,7 @@ def test_no_noise():
     cirq.testing.assert_equivalent_repr(cirq.NO_NOISE)
 
 
-def test_constant_qubit_noise():
+def test_constant_qubit_noise() -> None:
     a, b, c = cirq.LineQubit.range(3)
     damp = cirq.amplitude_damp(0.5)
     damp_all = cirq.ConstantQubitNoiseModel(damp)
@@ -124,7 +128,7 @@ def test_constant_qubit_noise():
         _ = cirq.ConstantQubitNoiseModel(cirq.CNOT**0.01)
 
 
-def test_constant_qubit_noise_prepend():
+def test_constant_qubit_noise_prepend() -> None:
     a, b, c = cirq.LineQubit.range(3)
     damp = cirq.amplitude_damp(0.5)
     damp_all = cirq.ConstantQubitNoiseModel(damp, prepend=True)
@@ -143,7 +147,7 @@ def test_constant_qubit_noise_prepend():
     cirq.testing.assert_equivalent_repr(damp_all)
 
 
-def test_noise_composition():
+def test_noise_composition() -> None:
     # Verify that noise models can be composed without regard to ordering, as
     # long as the noise operators commute with one another.
     a, b, c = cirq.LineQubit.range(3)
@@ -172,11 +176,11 @@ def test_noise_composition():
     assert_equivalent_op_tree(actual_zs, expected_circuit)
 
 
-def test_constant_qubit_noise_repr():
+def test_constant_qubit_noise_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.ConstantQubitNoiseModel(cirq.X**0.01))
 
 
-def test_wrap():
+def test_wrap() -> None:
     class Forget(cirq.NoiseModel):
         def noisy_operation(self, operation):
             raise NotImplementedError()
@@ -193,13 +197,13 @@ def test_wrap():
     assert cirq.NoiseModel.from_noise_model_like(forget) is forget
 
     with pytest.raises(TypeError, match='Expected a NOISE_MODEL_LIKE'):
-        _ = cirq.NoiseModel.from_noise_model_like('test')
+        _ = cirq.NoiseModel.from_noise_model_like('test')  # type: ignore[arg-type]
 
     with pytest.raises(ValueError, match='Multi-qubit gate'):
         _ = cirq.NoiseModel.from_noise_model_like(cirq.CZ**0.01)
 
 
-def test_gate_substitution_noise_model():
+def test_gate_substitution_noise_model() -> None:
     def _overrotation(op):
         if isinstance(op.gate, cirq.XPowGate):
             return cirq.XPowGate(exponent=op.gate.exponent + 0.1).on(*op.qubits)
@@ -215,14 +219,14 @@ def test_gate_substitution_noise_model():
     np.testing.assert_allclose(rho1, rho2)
 
 
-def test_moment_is_measurements():
+def test_moment_is_measurements() -> None:
     q = cirq.LineQubit.range(2)
     circ = cirq.Circuit([cirq.X(q[0]), cirq.X(q[1]), cirq.measure(*q, key='z')])
     assert not validate_all_measurements(circ[0])
     assert validate_all_measurements(circ[1])
 
 
-def test_moment_is_measurements_mixed1():
+def test_moment_is_measurements_mixed1() -> None:
     q = cirq.LineQubit.range(2)
     circ = cirq.Circuit([cirq.X(q[0]), cirq.X(q[1]), cirq.measure(q[0], key='z'), cirq.Z(q[1])])
     assert not validate_all_measurements(circ[0])
@@ -231,7 +235,7 @@ def test_moment_is_measurements_mixed1():
     assert e.match(".*must be homogeneous: all measurements.*")
 
 
-def test_moment_is_measurements_mixed2():
+def test_moment_is_measurements_mixed2() -> None:
     q = cirq.LineQubit.range(2)
     circ = cirq.Circuit([cirq.X(q[0]), cirq.X(q[1]), cirq.Z(q[0]), cirq.measure(q[1], key='z')])
     assert not validate_all_measurements(circ[0])

cirq/devices/noise_properties.py

@@ -19,10 +19,12 @@ be translated into noise models. NoiseModelFromNoiseProperties consumes those
 noise models to produce a single noise model which replicates device noise.
 """
 
+from __future__ import annotations
+
 import abc
-from typing import Iterable, List, Sequence, TYPE_CHECKING
+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")
@@ -35,10 +37,11 @@ class NoiseProperties(abc.ABC):
     """Noise-defining properties for a quantum device."""
 
     @abc.abstractmethod
-    def build_noise_models(self) -> List['cirq.NoiseModel']:
+    def build_noise_models(self) -> list[cirq.NoiseModel]:
         """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.
@@ -52,7 +55,10 @@ class NoiseModelFromNoiseProperties(devices.NoiseModel):
         self._noise_properties = noise_properties
         self.noise_models = self._noise_properties.build_noise_models()
 
-    def is_virtual(self, op: 'cirq.Operation') -> bool:
+    def _value_equality_values_(self):
+        return self._noise_properties
+
+    def is_virtual(self, op: cirq.Operation) -> bool:
         """Returns True if an operation is virtual.
 
         Device-specific subclasses should implement this method to mark any
@@ -67,8 +73,8 @@ class NoiseModelFromNoiseProperties(devices.NoiseModel):
         return False
 
     def noisy_moments(
-        self, moments: Iterable['cirq.Moment'], system_qubits: Sequence['cirq.Qid']
-    ) -> Sequence['cirq.OP_TREE']:
+        self, moments: Iterable[cirq.Moment], system_qubits: Sequence[cirq.Qid]
+    ) -> Sequence[cirq.OP_TREE]:
         # Split multi-qubit measurements into single-qubit measurements.
         # These will be recombined after noise is applied.
         split_measure_moments = []
@@ -124,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

@@ -12,18 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List, Tuple
+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]]):
+    def __init__(self, system_qubits: list[cirq.Qid], qubit_pairs: list[tuple[cirq.Qid, cirq.Qid]]):
         self.qubits = system_qubits
         self.qubit_pairs = qubit_pairs
 
@@ -34,8 +41,18 @@ 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}
 
-def test_sample_model():
+    @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)
     props = SampleNoiseProperties([q0, q1], [(q0, q1), (q1, q0)])
     model = NoiseModelFromNoiseProperties(props)
@@ -54,3 +71,17 @@ def test_sample_model():
         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/noise_utils.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Tuple, Type, TYPE_CHECKING, Union
+from __future__ import annotations
+
+from typing import Any, TYPE_CHECKING
 
 from cirq import ops, protocols, qis, value
 from cirq._compat import deprecated, proper_repr
@@ -29,24 +31,24 @@ PHYSICAL_GATE_TAG = 'physical_gate'
 class OpIdentifier:
     """Identifies an operation by gate and (optionally) target qubits."""
 
-    def __init__(self, gate_type: Type['cirq.Gate'], *qubits: 'cirq.Qid'):
+    def __init__(self, gate_type: type[cirq.Gate], *qubits: cirq.Qid):
         self._gate_type = gate_type
         self._gate_family = ops.GateFamily(gate_type)
-        self._qubits: Tuple['cirq.Qid', ...] = tuple(qubits)
+        self._qubits: tuple[cirq.Qid, ...] = tuple(qubits)
 
     @property
-    def gate_type(self) -> Type['cirq.Gate']:
+    def gate_type(self) -> type[cirq.Gate]:
         # set to a type during initialization, never modified
         return self._gate_type
 
     @property
-    def qubits(self) -> Tuple['cirq.Qid', ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         return self._qubits
 
     def _predicate(self, *args, **kwargs):
         return self._gate_family._predicate(*args, **kwargs)
 
-    def is_proper_subtype_of(self, op_id: 'OpIdentifier'):
+    def is_proper_subtype_of(self, op_id: OpIdentifier):
         """Returns true if this is contained within op_id, but not equal to it.
 
         If this returns true, (x in self) implies (x in op_id), but the reverse
@@ -65,7 +67,7 @@ class OpIdentifier:
         else:
             return False
 
-    def __contains__(self, item: Union[ops.Gate, ops.Operation]) -> bool:
+    def __contains__(self, item: ops.Gate | ops.Operation) -> bool:
         if isinstance(item, ops.Gate):
             return (not self._qubits) and self._predicate(item)
         return (
@@ -84,13 +86,13 @@ class OpIdentifier:
     def _value_equality_values_(self) -> Any:
         return (self.gate_type, self.qubits)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         if hasattr(self.gate_type, '__name__'):
             return {'gate_type': protocols.json_cirq_type(self._gate_type), 'qubits': self._qubits}
         return {'gate_type': self._gate_type, 'qubits': self._qubits}
 
     @classmethod
-    def _from_json_dict_(cls, gate_type, qubits, **kwargs) -> 'OpIdentifier':
+    def _from_json_dict_(cls, gate_type, qubits, **kwargs) -> OpIdentifier:
         if isinstance(gate_type, str):
             gate_type = protocols.cirq_type_from_json(gate_type)
         return cls(gate_type, *qubits)

cirq/devices/noise_utils_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
 from cirq.devices.noise_utils import OpIdentifier
 

cirq/devices/superconducting_qubits_noise_properties.py

@@ -12,13 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 """Class for representing noise on a superconducting qubit device."""
 
+from __future__ import annotations
+
 import abc
 from dataclasses import dataclass, field
 from functools import cached_property
-from typing import Dict, List, Set, Type, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from cirq import devices, ops, qis
 from cirq.devices import noise_utils
@@ -33,11 +34,11 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
     """Noise-defining properties for a superconducting-qubit-based device.
 
     Args:
-        gate_times_ns: Dict[type, float] of gate types to their duration on
+        gate_times_ns: dict[type, float] of gate types to their duration on
             quantum hardware. Used with t(1|phi)_ns to specify thermal noise.
-        t1_ns: Dict[cirq.Qid, float] of qubits to their T_1 time, in ns.
-        tphi_ns: Dict[cirq.Qid, float] of qubits to their T_phi time, in ns.
-        readout_errors: Dict[cirq.Qid, np.ndarray] of qubits to their readout
+        t1_ns: dict[cirq.Qid, float] of qubits to their T_1 time, in ns.
+        tphi_ns: dict[cirq.Qid, float] of qubits to their T_phi time, in ns.
+        readout_errors: dict[cirq.Qid, list[float]] of qubits to their readout
             errors in matrix form: [P(read |1> from |0>), P(read |0> from |1>)].
             Used to prepend amplitude damping errors to measurements.
         gate_pauli_errors: dict of noise_utils.OpIdentifiers (a gate and the qubits it
@@ -48,14 +49,14 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
             symmetric over the qubits they affect. Defaults to True.
     """
 
-    gate_times_ns: Dict[type, float]
-    t1_ns: Dict['cirq.Qid', float]
-    tphi_ns: Dict['cirq.Qid', float]
-    readout_errors: Dict['cirq.Qid', List[float]]
-    gate_pauli_errors: Dict[noise_utils.OpIdentifier, float]
+    gate_times_ns: dict[type, float]
+    t1_ns: dict[cirq.Qid, float]
+    tphi_ns: dict[cirq.Qid, float]
+    readout_errors: dict[cirq.Qid, list[float]]
+    gate_pauli_errors: dict[noise_utils.OpIdentifier, float]
 
     validate: bool = True
-    _qubits: List['cirq.Qid'] = field(init=False, default_factory=list)
+    _qubits: list[cirq.Qid] = field(init=False, default_factory=list)
 
     def __post_init__(self):
         if not self.validate:
@@ -95,7 +96,7 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
                 )
 
     @property
-    def qubits(self) -> List['cirq.Qid']:
+    def qubits(self) -> list[cirq.Qid]:
         """Qubits for which we have data"""
         if not self._qubits:
             self._qubits = sorted(self.t1_ns)
@@ -103,26 +104,26 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
 
     @classmethod
     @abc.abstractmethod
-    def single_qubit_gates(cls) -> Set[Type[ops.Gate]]:
+    def single_qubit_gates(cls) -> set[type[ops.Gate]]:
         """Returns the set of single-qubit gates this class supports."""
 
     @classmethod
     @abc.abstractmethod
-    def symmetric_two_qubit_gates(cls) -> Set[Type[ops.Gate]]:
+    def symmetric_two_qubit_gates(cls) -> set[type[ops.Gate]]:
         """Returns the set of symmetric two-qubit gates this class supports."""
 
     @classmethod
     @abc.abstractmethod
-    def asymmetric_two_qubit_gates(cls) -> Set[Type[ops.Gate]]:
+    def asymmetric_two_qubit_gates(cls) -> set[type[ops.Gate]]:
         """Returns the set of asymmetric two-qubit gates this class supports."""
 
     @classmethod
-    def two_qubit_gates(cls) -> Set[Type[ops.Gate]]:
+    def two_qubit_gates(cls) -> set[type[ops.Gate]]:
         """Returns the set of all two-qubit gates this class supports."""
         return cls.symmetric_two_qubit_gates() | cls.asymmetric_two_qubit_gates()
 
     @classmethod
-    def expected_gates(cls) -> Set[Type[ops.Gate]]:
+    def expected_gates(cls) -> set[type[ops.Gate]]:
         """Returns the set of all gates this class supports."""
         return cls.single_qubit_gates() | cls.two_qubit_gates()
 
@@ -133,7 +134,7 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
         return p_error
 
     @cached_property
-    def _depolarizing_error(self) -> Dict[noise_utils.OpIdentifier, float]:
+    def _depolarizing_error(self) -> dict[noise_utils.OpIdentifier, float]:
         """Returns the portion of Pauli error from depolarization."""
         depol_errors = {}
         for op_id, p_error in self.gate_pauli_errors.items():
@@ -150,8 +151,8 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
             depol_errors[op_id] = self._get_pauli_error(p_error, op_id)
         return depol_errors
 
-    def build_noise_models(self) -> List['cirq.NoiseModel']:
-        noise_models: List['cirq.NoiseModel'] = []
+    def build_noise_models(self) -> list[cirq.NoiseModel]:
+        noise_models: list[cirq.NoiseModel] = []
 
         if self.t1_ns:
             noise_models.append(
@@ -175,7 +176,7 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
 
         # This adds per-qubit measurement error BEFORE measurement on those qubits.
         if self.readout_errors:
-            added_measure_errors: Dict[noise_utils.OpIdentifier, 'cirq.Operation'] = {}
+            added_measure_errors: dict[noise_utils.OpIdentifier, cirq.Operation] = {}
             for qubit in self.readout_errors:
                 p_00, p_11 = self.readout_errors[qubit]
                 p = p_11 / (p_00 + p_11)

cirq/devices/superconducting_qubits_noise_properties_test.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict, List, Set, Tuple
+from __future__ import annotations
 
 import numpy as np
 import pytest
@@ -24,7 +24,7 @@ from cirq.devices.superconducting_qubits_noise_properties import (
     SuperconductingQubitsNoiseProperties,
 )
 
-DEFAULT_GATE_NS: Dict[type, float] = {
+DEFAULT_GATE_NS: dict[type, float] = {
     cirq.ZPowGate: 25.0,
     cirq.MeasurementGate: 4000.0,
     cirq.ResetChannel: 250.0,
@@ -37,7 +37,7 @@ DEFAULT_GATE_NS: Dict[type, float] = {
 }
 
 
-def default_props(system_qubits: List[cirq.Qid], qubit_pairs: List[Tuple[cirq.Qid, cirq.Qid]]):
+def default_props(system_qubits: list[cirq.Qid], qubit_pairs: list[tuple[cirq.Qid, cirq.Qid]]):
     return {
         'gate_times_ns': DEFAULT_GATE_NS,
         't1_ns': {q: 1e5 for q in system_qubits},
@@ -63,15 +63,15 @@ class ExampleNoiseProperties(SuperconductingQubitsNoiseProperties):
         super().__init__(*args, **kwargs)
 
     @classmethod
-    def single_qubit_gates(cls) -> Set[type]:
+    def single_qubit_gates(cls) -> set[type]:
         return {cirq.ZPowGate, cirq.PhasedXZGate, cirq.MeasurementGate, cirq.ResetChannel}
 
     @classmethod
-    def symmetric_two_qubit_gates(cls) -> Set[type]:
+    def symmetric_two_qubit_gates(cls) -> set[type]:
         return {cirq.FSimGate, cirq.PhasedFSimGate, cirq.ISwapPowGate, cirq.CZPowGate}
 
     @classmethod
-    def asymmetric_two_qubit_gates(cls) -> Set[type]:
+    def asymmetric_two_qubit_gates(cls) -> set[type]:
         return set()