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

cirq/ops/measure_util.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Callable, Dict, Iterable, List, Optional, overload, Tuple, TYPE_CHECKING, Union
+from __future__ import annotations
+
+from typing import Callable, Iterable, overload, TYPE_CHECKING
 
 import numpy as np
 
@@ -30,8 +32,7 @@ def _default_measurement_key(qubits: Iterable[raw_types.Qid]) -> str:
 
 
 def measure_single_paulistring(
-    pauli_observable: pauli_string.PauliString,
-    key: Optional[Union[str, 'cirq.MeasurementKey']] = None,
+    pauli_observable: pauli_string.PauliString, key: str | cirq.MeasurementKey | None = None
 ) -> raw_types.Operation:
     """Returns a single PauliMeasurementGate which measures the pauli observable
 
@@ -66,7 +67,7 @@ def measure_single_paulistring(
 
 def measure_paulistring_terms(
     pauli_basis: pauli_string.PauliString, key_func: Callable[[raw_types.Qid], str] = str
-) -> List[raw_types.Operation]:
+) -> list[raw_types.Operation]:
     """Returns a list of operations individually measuring qubits in the pauli basis.
 
     Args:
@@ -89,14 +90,11 @@ def measure_paulistring_terms(
     return [PauliMeasurementGate([pauli_basis[q]], key=key_func(q)).on(q) for q in pauli_basis]
 
 
-# pylint: disable=function-redefined
-
-
 @overload
 def measure(
     *target: raw_types.Qid,
-    key: Optional[Union[str, 'cirq.MeasurementKey']] = None,
-    invert_mask: Tuple[bool, ...] = (),
+    key: str | cirq.MeasurementKey | None = None,
+    invert_mask: tuple[bool, ...] = (),
 ) -> raw_types.Operation:
     pass
 
@@ -105,17 +103,17 @@ def measure(
 def measure(
     __target: Iterable[raw_types.Qid],
     *,
-    key: Optional[Union[str, 'cirq.MeasurementKey']] = None,
-    invert_mask: Tuple[bool, ...] = (),
+    key: str | cirq.MeasurementKey | None = None,
+    invert_mask: tuple[bool, ...] = (),
 ) -> raw_types.Operation:
     pass
 
 
 def measure(
     *target,
-    key: Optional[Union[str, 'cirq.MeasurementKey']] = None,
-    invert_mask: Tuple[bool, ...] = (),
-    confusion_map: Optional[Dict[Tuple[int, ...], np.ndarray]] = None,
+    key: str | cirq.MeasurementKey | None = None,
+    invert_mask: tuple[bool, ...] = (),
+    confusion_map: dict[tuple[int, ...], np.ndarray] | None = None,
 ) -> raw_types.Operation:
     """Returns a single MeasurementGate applied to all the given qubits.
 
@@ -170,20 +168,20 @@ M = measure
 @overload
 def measure_each(
     *qubits: raw_types.Qid, key_func: Callable[[raw_types.Qid], str] = str
-) -> List[raw_types.Operation]:
+) -> list[raw_types.Operation]:
     pass
 
 
 @overload
 def measure_each(
     __qubits: Iterable[raw_types.Qid], *, key_func: Callable[[raw_types.Qid], str] = str
-) -> List[raw_types.Operation]:
+) -> list[raw_types.Operation]:
     pass
 
 
 def measure_each(
     *qubits, key_func: Callable[[raw_types.Qid], str] = str
-) -> List[raw_types.Operation]:
+) -> list[raw_types.Operation]:
     """Returns a list of operations individually measuring the given qubits.
 
     The qubits are measured in the computational basis.
@@ -204,6 +202,3 @@ def measure_each(
     )
     qubitsequence = qubits[0] if one_iterable_arg else qubits
     return [MeasurementGate(1, key_func(q), qid_shape=(q.dimension,)).on(q) for q in qubitsequence]
-
-
-# pylint: enable=function-redefined

cirq/ops/measure_util_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
 

cirq/ops/measurement_gate.py

@@ -12,18 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import (
-    Any,
-    Dict,
-    FrozenSet,
-    Iterable,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from __future__ import annotations
+
+from typing import Any, Iterable, Mapping, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -47,11 +38,11 @@ class MeasurementGate(raw_types.Gate):
 
     def __init__(
         self,
-        num_qubits: Optional[int] = None,
-        key: Union[str, 'cirq.MeasurementKey'] = '',
-        invert_mask: Tuple[bool, ...] = (),
-        qid_shape: Optional[Tuple[int, ...]] = None,
-        confusion_map: Optional[Dict[Tuple[int, ...], np.ndarray]] = None,
+        num_qubits: int | None = None,
+        key: str | cirq.MeasurementKey = '',
+        invert_mask: tuple[bool, ...] = (),
+        qid_shape: tuple[int, ...] | None = None,
+        confusion_map: dict[tuple[int, ...], np.ndarray] | None = None,
     ) -> None:
         """Inits MeasurementGate.
 
@@ -100,24 +91,24 @@ class MeasurementGate(raw_types.Gate):
         return str(self.mkey)
 
     @property
-    def mkey(self) -> 'cirq.MeasurementKey':
+    def mkey(self) -> cirq.MeasurementKey:
         return self._mkey
 
     @property
-    def invert_mask(self) -> Tuple[bool, ...]:
+    def invert_mask(self) -> tuple[bool, ...]:
         return self._invert_mask
 
     @property
-    def confusion_map(self) -> Dict[Tuple[int, ...], np.ndarray]:
+    def confusion_map(self) -> dict[tuple[int, ...], np.ndarray]:
         return self._confusion_map
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return self._qid_shape
 
     def _has_unitary_(self) -> bool:
         return False
 
-    def with_key(self, key: Union[str, 'cirq.MeasurementKey']) -> 'MeasurementGate':
+    def with_key(self, key: str | cirq.MeasurementKey) -> MeasurementGate:
         """Creates a measurement gate with a new key but otherwise identical."""
         if key == self.key:
             return self
@@ -129,21 +120,21 @@ class MeasurementGate(raw_types.Gate):
             confusion_map=self.confusion_map,
         )
 
-    def _with_key_path_(self, path: Tuple[str, ...]):
+    def _with_key_path_(self, path: tuple[str, ...]):
         return self.with_key(self.mkey._with_key_path_(path))
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]):
+    def _with_key_path_prefix_(self, prefix: tuple[str, ...]):
         return self.with_key(self.mkey._with_key_path_prefix_(prefix))
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
+        self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]
     ):
         return self.with_key(protocols.with_rescoped_keys(self.mkey, path, bindable_keys))
 
     def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]):
         return self.with_key(protocols.with_measurement_key_mapping(self.mkey, key_map))
 
-    def with_bits_flipped(self, *bit_positions: int) -> 'MeasurementGate':
+    def with_bits_flipped(self, *bit_positions: int) -> MeasurementGate:
         """Toggles whether or not the measurement inverts various outputs.
 
         This only affects the invert_mask, which is applied after confusion
@@ -162,7 +153,7 @@ class MeasurementGate(raw_types.Gate):
             confusion_map=self.confusion_map,
         )
 
-    def full_invert_mask(self) -> Tuple[bool, ...]:
+    def full_invert_mask(self) -> tuple[bool, ...]:
         """Returns the invert mask for all qubits.
 
         If the user supplies a partial invert_mask, this returns that mask
@@ -182,7 +173,7 @@ class MeasurementGate(raw_types.Gate):
     def _measurement_key_name_(self) -> str:
         return self.key
 
-    def _measurement_key_obj_(self) -> 'cirq.MeasurementKey':
+    def _measurement_key_obj_(self) -> cirq.MeasurementKey:
         return self.mkey
 
     def _kraus_(self):
@@ -198,9 +189,7 @@ class MeasurementGate(raw_types.Gate):
     def _has_kraus_(self):
         return True
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         symbols = ['M'] * self.num_qubits()
         flipped_indices = {i for i, x in enumerate(self.full_invert_mask()) if x}
         confused_indices = {x for idxs in self.confusion_map for x in idxs}
@@ -224,7 +213,7 @@ class MeasurementGate(raw_types.Gate):
 
         return protocols.CircuitDiagramInfo(symbols)
 
-    def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, qubits: tuple[cirq.Qid, ...]) -> str | None:
         if self.confusion_map or not all(d == 2 for d in self._qid_shape):
             return NotImplemented
         args.validate_version('2.0', '3.0')
@@ -243,7 +232,7 @@ class MeasurementGate(raw_types.Gate):
                 lines.append(args.format('x {0};  // Undo the inversion\n', qubit))
         return ''.join(lines)
 
-    def _op_repr_(self, qubits: Sequence['cirq.Qid']) -> str:
+    def _op_repr_(self, qubits: Sequence[cirq.Qid]) -> str:
         args = list(repr(q) for q in qubits)
         if self.key != _default_measurement_key(qubits):
             args.append(f'key={self.mkey!r}')
@@ -275,8 +264,8 @@ class MeasurementGate(raw_types.Gate):
         )
         return self.key, self.full_invert_mask(), self._qid_shape, hashable_cmap
 
-    def _json_dict_(self) -> Dict[str, Any]:
-        other: Dict[str, Any] = {}
+    def _json_dict_(self) -> dict[str, Any]:
+        other: dict[str, Any] = {}
         if not all(d == 2 for d in self._qid_shape):
             other['qid_shape'] = self._qid_shape
         if self.confusion_map:
@@ -301,10 +290,10 @@ class MeasurementGate(raw_types.Gate):
             confusion_map={tuple(k): np.array(v) for k, v in confusion_map or []},
         )
 
-    def _has_stabilizer_effect_(self) -> Optional[bool]:
+    def _has_stabilizer_effect_(self) -> bool | None:
         return True
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase', qubits: Sequence['cirq.Qid']) -> bool:
+    def _act_on_(self, sim_state: cirq.SimulationStateBase, qubits: Sequence[cirq.Qid]) -> bool:
         from cirq.sim import SimulationState
 
         if not isinstance(sim_state, SimulationState):

cirq/ops/measurement_gate_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 cast
 
 import numpy as np

cirq/ops/mixed_unitary_channel.py

@@ -1,5 +1,8 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
-from typing import Any, Dict, FrozenSet, Iterable, Mapping, Tuple, TYPE_CHECKING, Union
+
+from __future__ import annotations
+
+from typing import Any, Iterable, Mapping, TYPE_CHECKING
 
 import numpy as np
 
@@ -27,8 +30,8 @@ class MixedUnitaryChannel(raw_types.Gate):
 
     def __init__(
         self,
-        mixture: Iterable[Tuple[float, np.ndarray]],
-        key: Union[str, 'cirq.MeasurementKey', None] = None,
+        mixture: Iterable[tuple[float, np.ndarray]],
+        key: str | cirq.MeasurementKey | None = None,
         validate: bool = False,
     ):
         mixture = list(mixture)
@@ -58,7 +61,7 @@ class MixedUnitaryChannel(raw_types.Gate):
 
     @staticmethod
     def from_mixture(
-        mixture: 'protocols.SupportsMixture', key: Union[str, 'cirq.MeasurementKey', None] = None
+        mixture: protocols.SupportsMixture, key: str | cirq.MeasurementKey | None = None
     ):
         """Creates a copy of a mixture with the given measurement key."""
         return MixedUnitaryChannel(mixture=list(protocols.mixture(mixture)), key=key)
@@ -85,7 +88,7 @@ class MixedUnitaryChannel(raw_types.Gate):
             return NotImplemented
         return str(self._key)
 
-    def _measurement_key_obj_(self) -> 'cirq.MeasurementKey':
+    def _measurement_key_obj_(self) -> cirq.MeasurementKey:
         if self._key is None:
             return NotImplemented
         return self._key
@@ -97,18 +100,18 @@ class MixedUnitaryChannel(raw_types.Gate):
             return self
         return MixedUnitaryChannel(mixture=self._mixture, key=key_map[str(self._key)])
 
-    def _with_key_path_(self, path: Tuple[str, ...]):
+    def _with_key_path_(self, path: tuple[str, ...]):
         return MixedUnitaryChannel(
             mixture=self._mixture, key=protocols.with_key_path(self._key, path)
         )
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]):
+    def _with_key_path_prefix_(self, prefix: tuple[str, ...]):
         return MixedUnitaryChannel(
             mixture=self._mixture, key=protocols.with_key_path_prefix(self._key, prefix)
         )
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
+        self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]
     ):
         return MixedUnitaryChannel(
             mixture=self._mixture, key=protocols.with_rescoped_keys(self._key, path, bindable_keys)
@@ -128,7 +131,7 @@ class MixedUnitaryChannel(raw_types.Gate):
             args.append(f'key=\'{self._key}\'')
         return f'cirq.MixedUnitaryChannel({", ".join(args)})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['_mixture', '_key'])
 
     @classmethod

cirq/ops/mixed_unitary_channel_test.py

@@ -1,11 +1,14 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import numpy as np
 import pytest
 
 import cirq
 
 
-def test_matrix_mixture_from_mixture():
+def test_matrix_mixture_from_mixture() -> None:
     q0 = cirq.LineQubit(0)
     dp = cirq.depolarize(0.1)
     mm = cirq.MixedUnitaryChannel.from_mixture(dp, key='dp')
@@ -22,7 +25,7 @@ def test_matrix_mixture_from_mixture():
     assert results.measurements['dp'] in range(4)
 
 
-def test_matrix_mixture_equality():
+def test_matrix_mixture_equality() -> None:
     dp_pt1 = cirq.depolarize(0.1)
     dp_pt2 = cirq.depolarize(0.2)
     mm_a1 = cirq.MixedUnitaryChannel.from_mixture(dp_pt1, key='a')
@@ -45,7 +48,7 @@ def test_matrix_mixture_equality():
     assert half_flip != half_flip_inv
 
 
-def test_matrix_mixture_remap_keys():
+def test_matrix_mixture_remap_keys() -> None:
     dp = cirq.depolarize(0.1)
     mm = cirq.MixedUnitaryChannel.from_mixture(dp)
     with pytest.raises(TypeError):
@@ -63,7 +66,7 @@ def test_matrix_mixture_remap_keys():
     assert cirq.with_measurement_key_mapping(mm_a, {'a': 'b'}) == mm_b
 
 
-def test_matrix_mixture_from_unitaries():
+def test_matrix_mixture_from_unitaries() -> None:
     q0 = cirq.LineQubit(0)
     mix = [(0.5, np.array([[1, 0], [0, 1]])), (0.5, np.array([[0, 1], [1, 0]]))]
     half_flip = cirq.MixedUnitaryChannel(mix, key='flip')
@@ -77,7 +80,7 @@ def test_matrix_mixture_from_unitaries():
     assert results.measurements['flip'] == results.measurements['m']
 
 
-def test_matrix_mixture_str():
+def test_matrix_mixture_str() -> None:
     mix = [(0.5, np.array([[1, 0], [0, 1]])), (0.5, np.array([[0, 1], [1, 0]]))]
     half_flip = cirq.MixedUnitaryChannel(mix)
     assert (
@@ -95,7 +98,7 @@ def test_matrix_mixture_str():
     )
 
 
-def test_matrix_mixture_repr():
+def test_matrix_mixture_repr() -> None:
     mix = [
         (0.5, np.array([[1, 0], [0, 1]], dtype=np.dtype('complex64'))),
         (0.5, np.array([[0, 1], [1, 0]], dtype=np.dtype('complex64'))),
@@ -111,19 +114,19 @@ key='flip')"""
     )
 
 
-def test_mix_no_unitaries_fails():
+def test_mix_no_unitaries_fails() -> None:
     with pytest.raises(ValueError, match='must have at least one unitary'):
         _ = cirq.MixedUnitaryChannel(mixture=[], key='m')
 
 
-def test_mix_bad_prob_fails():
+def test_mix_bad_prob_fails() -> None:
     mix = [(0.5, np.array([[1, 0], [0, 0]]))]
 
     with pytest.raises(ValueError, match='Unitary probabilities must sum to 1'):
         _ = cirq.MixedUnitaryChannel(mixture=mix, key='m')
 
 
-def test_mix_mismatch_fails():
+def test_mix_mismatch_fails() -> None:
     op2 = np.zeros((4, 4))
     op2[1][1] = 1
     mix = [(0.5, np.array([[1, 0], [0, 0]])), (0.5, op2)]
@@ -132,14 +135,14 @@ def test_mix_mismatch_fails():
         _ = cirq.MixedUnitaryChannel(mixture=mix, key='m')
 
 
-def test_nonqubit_mixture_fails():
+def test_nonqubit_mixture_fails() -> None:
     mix = [(0.5, np.array([[1, 0, 0], [0, 1, 0]])), (0.5, np.array([[0, 1, 0], [1, 0, 0]]))]
 
     with pytest.raises(ValueError, match='Input mixture'):
         _ = cirq.MixedUnitaryChannel(mixture=mix, key='m')
 
 
-def test_validate():
+def test_validate() -> None:
     mix = [(0.5, np.array([[1, 0], [0, 0]])), (0.5, np.array([[0, 0], [0, 1]]))]
     with pytest.raises(ValueError, match='non-unitary'):
         _ = cirq.MixedUnitaryChannel(mixture=mix, key='m', validate=True)

cirq/ops/named_qubit.py

@@ -11,9 +11,12 @@
 # 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.
+
+from __future__ import annotations
+
 import functools
 import weakref
-from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 from cirq import protocols
 from cirq.ops import raw_types
@@ -28,8 +31,8 @@ class _BaseNamedQid(raw_types.Qid):
 
     _name: str
     _dimension: int
-    _comp_key: Optional[str] = None
-    _hash: Optional[int] = None
+    _comp_key: str | None = None
+    _hash: int | None = None
 
     def __hash__(self) -> int:
         if self._hash is None:
@@ -93,7 +96,7 @@ class _BaseNamedQid(raw_types.Qid):
     def dimension(self) -> int:
         return self._dimension
 
-    def with_dimension(self, dimension: int) -> 'NamedQid':
+    def with_dimension(self, dimension: int) -> NamedQid:
         return NamedQid(self._name, dimension=dimension)
 
 
@@ -109,9 +112,9 @@ class NamedQid(_BaseNamedQid):
 
     # Cache of existing NamedQid instances, returned by __new__ if available.
     # Holds weak references so instances can still be garbage collected.
-    _cache = weakref.WeakValueDictionary[Tuple[str, int], 'cirq.NamedQid']()
+    _cache = weakref.WeakValueDictionary[tuple[str, int], 'cirq.NamedQid']()
 
-    def __new__(cls, name: str, dimension: int) -> 'cirq.NamedQid':
+    def __new__(cls, name: str, dimension: int) -> cirq.NamedQid:
         """Initializes a `NamedQid` with a given name and dimension.
 
         Args:
@@ -134,7 +137,7 @@ class NamedQid(_BaseNamedQid):
         return (self._name, self._dimension)
 
     # avoid pickling the _hash value, attributes are already stored with __getnewargs__
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         return {}
 
     def __repr__(self) -> str:
@@ -144,7 +147,7 @@ class NamedQid(_BaseNamedQid):
         return f'{self._name} (d={self._dimension})'
 
     @staticmethod
-    def range(*args, prefix: str, dimension: int) -> List['NamedQid']:
+    def range(*args, prefix: str, dimension: int) -> list[NamedQid]:
         """Returns a range of ``NamedQid``\\s.
 
         The range returned starts with the prefix, and followed by a qid for
@@ -167,7 +170,7 @@ class NamedQid(_BaseNamedQid):
         """
         return [NamedQid(f"{prefix}{i}", dimension=dimension) for i in range(*args)]
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['name', 'dimension'])
 
 
@@ -186,7 +189,7 @@ class NamedQubit(_BaseNamedQid):
     # Holds weak references so instances can still be garbage collected.
     _cache = weakref.WeakValueDictionary[str, 'cirq.NamedQubit']()
 
-    def __new__(cls, name: str) -> 'cirq.NamedQubit':
+    def __new__(cls, name: str) -> cirq.NamedQubit:
         """Initializes a `NamedQid` with a given name and dimension.
 
         Args:
@@ -206,7 +209,7 @@ class NamedQubit(_BaseNamedQid):
         return (self._name,)
 
     # avoid pickling the _hash value, attributes are already stored with __getnewargs__
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         return {}
 
     def __str__(self) -> str:
@@ -216,7 +219,7 @@ class NamedQubit(_BaseNamedQid):
         return f'cirq.NamedQubit({self._name!r})'
 
     @staticmethod
-    def range(*args, prefix: str) -> List['NamedQubit']:
+    def range(*args, prefix: str) -> list[NamedQubit]:
         r"""Returns a range of `cirq.NamedQubit`s.
 
         The range returned starts with the prefix, and followed by a qubit for
@@ -238,7 +241,7 @@ class NamedQubit(_BaseNamedQid):
         """
         return [NamedQubit(f"{prefix}{i}") for i in range(*args)]
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['name'])
 
 

cirq/ops/named_qubit_test.py

@@ -12,21 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 from cirq.devices.grid_qubit_test import _test_qid_pickled_hash
 from cirq.ops.named_qubit import _pad_digits
 
 
-def test_init():
+def test_init() -> None:
     q = cirq.NamedQubit('a')
     assert q.name == 'a'
 
-    q = cirq.NamedQid('a', dimension=3)
-    assert q.name == 'a'
-    assert q.dimension == 3
+    qid = cirq.NamedQid('a', dimension=3)
+    assert qid.name == 'a'
+    assert qid.dimension == 3
 
 
-def test_named_qubit_str():
+def test_named_qubit_str() -> None:
     q = cirq.NamedQubit('a')
     assert q.name == 'a'
     assert str(q) == 'a'
@@ -35,14 +37,14 @@ def test_named_qubit_str():
     assert str(qid) == 'a (d=3)'
 
 
-def test_named_qubit_repr():
+def test_named_qubit_repr() -> None:
     q = cirq.NamedQubit('a')
     assert repr(q) == "cirq.NamedQubit('a')"
     qid = cirq.NamedQid('a', dimension=3)
     assert repr(qid) == "cirq.NamedQid('a', dimension=3)"
 
 
-def test_named_qubit_pickled_hash():
+def test_named_qubit_pickled_hash() -> None:
     # Use a name that is unlikely to be used by any other tests.
     x = "test_named_qubit_pickled_hash"
     q_bad = cirq.NamedQubit(x)
@@ -51,7 +53,7 @@ def test_named_qubit_pickled_hash():
     _test_qid_pickled_hash(q, q_bad)
 
 
-def test_named_qid_pickled_hash():
+def test_named_qid_pickled_hash() -> None:
     # Use a name that is unlikely to be used by any other tests.
     x = "test_named_qid_pickled_hash"
     q_bad = cirq.NamedQid(x, dimension=3)
@@ -60,7 +62,7 @@ def test_named_qid_pickled_hash():
     _test_qid_pickled_hash(q, q_bad)
 
 
-def test_named_qubit_order():
+def test_named_qubit_order() -> None:
     order = cirq.testing.OrderTester()
     order.add_ascending(
         cirq.NamedQid('', dimension=1),
@@ -108,7 +110,7 @@ def test_named_qubit_order():
     )
 
 
-def test_pad_digits():
+def test_pad_digits() -> None:
     assert _pad_digits('') == ''
     assert _pad_digits('a') == 'a'
     assert _pad_digits('a0') == 'a00000000:1'
@@ -119,7 +121,7 @@ def test_pad_digits():
     assert _pad_digits('a00000000:8') == 'a00000000:8:00000008:1'
 
 
-def test_named_qubit_range():
+def test_named_qubit_range() -> None:
     qubits = cirq.NamedQubit.range(2, prefix='a')
     assert qubits == [cirq.NamedQubit('a0'), cirq.NamedQubit('a1')]
 
@@ -127,7 +129,7 @@ def test_named_qubit_range():
     assert qubits == [cirq.NamedQubit('a-1'), cirq.NamedQubit('a1'), cirq.NamedQubit('a3')]
 
 
-def test_named_qid_range():
+def test_named_qid_range() -> None:
     qids = cirq.NamedQid.range(2, prefix='a', dimension=3)
     assert qids == [cirq.NamedQid('a0', dimension=3), cirq.NamedQid('a1', dimension=3)]
 
@@ -149,7 +151,7 @@ def test_named_qid_range():
     ]
 
 
-def test_to_json():
+def test_to_json() -> None:
     assert cirq.NamedQubit('c')._json_dict_() == {'name': 'c'}
 
     assert cirq.NamedQid('c', dimension=3)._json_dict_() == {'name': 'c', 'dimension': 3}