Merge branch 'main' into mh-fix-size-labeler

Author: mhucka

.github/workflows/pr-labeler.yaml

@@ -51,6 +51,7 @@ jobs:
     timeout-minutes: 5
     permissions:
       contents: read
+      issues: write
       pull-requests: write
     env:
       PR_NUMBER: ${{inputs.pr-number || github.event.pull_request.number}}

cirq-core/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
@@ -77,7 +79,7 @@ def noisy_moment(self, moment, system_qubits):
     )
 
     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()

cirq-core/cirq/devices/noise_properties.py

@@ -19,6 +19,8 @@
 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
 
@@ -35,7 +37,7 @@ 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."""
 
 
@@ -52,7 +54,7 @@ def __init__(self, noise_properties: NoiseProperties) -> None:
         self._noise_properties = noise_properties
         self.noise_models = self._noise_properties.build_noise_models()
 
-    def is_virtual(self, op: 'cirq.Operation') -> bool:
+    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 +69,8 @@ def is_virtual(self, op: 'cirq.Operation') -> bool:
         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 = []

cirq-core/cirq/devices/noise_utils.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 Any, Dict, Tuple, Type, TYPE_CHECKING, Union
 
 from cirq import ops, protocols, qis, value
@@ -29,24 +31,24 @@
 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
@@ -90,7 +92,7 @@ def _json_dict_(self) -> Dict[str, Any]:
         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-core/cirq/devices/superconducting_qubits_noise_properties.py

@@ -12,9 +12,10 @@
 # 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
@@ -49,13 +50,13 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
     """
 
     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]]
+    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 @@ def _validate_symmetric_errors(self, field_name: str) -> None:
                 )
 
     @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)
@@ -150,8 +151,8 @@ def _depolarizing_error(self) -> Dict[noise_utils.OpIdentifier, float]:
             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 @@ def build_noise_models(self) -> List['cirq.NoiseModel']:
 
         # 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-core/cirq/devices/thermal_noise_model.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import dataclasses
 import functools
 from typing import Dict, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
@@ -129,8 +131,8 @@ def _decoherence_matrix(
 
 
 def _as_rate_dict(
-    rate_or_dict: Optional[Union[float, Dict['cirq.Qid', float]]], qubits: Set['cirq.Qid']
-) -> Dict['cirq.Qid', float]:
+    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.
@@ -143,7 +145,7 @@ def _as_rate_dict(
         return {q: rate_or_dict for q in qubits}
 
 
-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.
@@ -169,11 +171,11 @@ class ThermalNoiseModel(devices.NoiseModel):
 
     def __init__(
         self,
-        qubits: Set['cirq.Qid'],
+        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,
+        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,
         require_physical_tag: bool = True,
         skip_measurements: bool = True,
         prepend: bool = False,
@@ -225,14 +227,12 @@ def __init__(
 
         _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.rate_matrix_GHz: Dict[cirq.Qid, np.ndarray] = rate_dict
         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 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,7 +247,7 @@ def noisy_moment(
                 # 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.

cirq-core/cirq/devices/unconstrained_device.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 Any, Dict, TYPE_CHECKING
 
 from cirq import protocols, value
@@ -26,7 +28,7 @@
 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:

cirq-core/cirq/experiments/n_qubit_tomography.py

@@ -17,6 +17,9 @@
 The code is designed to be modular with regards to data collection
 so that occurs outside of the StateTomographyExperiment class.
 """
+
+from __future__ import annotations
+
 from typing import List, Optional, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -49,7 +52,7 @@ class StateTomographyExperiment:
 
     def __init__(
         self,
-        qubits: Sequence['cirq.Qid'],
+        qubits: Sequence[cirq.Qid],
         prerotations: Optional[Sequence[Tuple[float, float]]] = None,
     ):
         """Initializes the rotation protocol and matrix for system.
@@ -69,8 +72,8 @@ def __init__(
 
         phase_exp_vals, exp_vals = zip(*prerotations)
 
-        operations: List['cirq.Operation'] = []
-        sweeps: List['cirq.Sweep'] = []
+        operations: List[cirq.Operation] = []
+        sweeps: List[cirq.Sweep] = []
         for i, qubit in enumerate(qubits):
             phase_exp = sympy.Symbol(f'phase_exp_{i}')
             exp = sympy.Symbol(f'exp_{i}')
@@ -82,7 +85,7 @@ def __init__(
         self.rot_sweep = study.Product(*sweeps)
         self.mat = self._make_state_tomography_matrix(qubits)
 
-    def _make_state_tomography_matrix(self, qubits: Sequence['cirq.Qid']) -> np.ndarray:
+    def _make_state_tomography_matrix(self, qubits: Sequence[cirq.Qid]) -> np.ndarray:
         """Gets the matrix used for solving the linear system of the tomography.
 
         Args:
@@ -130,9 +133,9 @@ def fit_density_matrix(self, counts: np.ndarray) -> TomographyResult:
 
 
 def state_tomography(
-    sampler: 'cirq.Sampler',
-    qubits: Sequence['cirq.Qid'],
-    circuit: 'cirq.Circuit',
+    sampler: cirq.Sampler,
+    qubits: Sequence[cirq.Qid],
+    circuit: cirq.Circuit,
     repetitions: int = 1000,
     prerotations: Optional[Sequence[Tuple[float, float]]] = None,
 ) -> TomographyResult:
@@ -166,11 +169,11 @@ def state_tomography(
 
 
 def get_state_tomography_data(
-    sampler: 'cirq.Sampler',
-    qubits: Sequence['cirq.Qid'],
-    circuit: 'cirq.Circuit',
-    rot_circuit: 'cirq.Circuit',
-    rot_sweep: 'cirq.Sweep',
+    sampler: cirq.Sampler,
+    qubits: Sequence[cirq.Qid],
+    circuit: cirq.Circuit,
+    rot_circuit: cirq.Circuit,
+    rot_sweep: cirq.Sweep,
     repetitions: int = 1000,
 ) -> np.ndarray:
     """Gets the data for each rotation string added to the circuit.