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

cirq/ops/dense_pauli_string.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 import numbers
 from types import NotImplementedType
@@ -20,16 +22,11 @@ from typing import (
     Any,
     Callable,
     cast,
-    Dict,
     Iterable,
     Iterator,
-    List,
-    Optional,
     overload,
     Sequence,
-    Tuple,
     TYPE_CHECKING,
-    Union,
 )
 
 import numpy as np
@@ -45,7 +42,7 @@ if TYPE_CHECKING:
 
 # Order is important! Index equals numeric value.
 PAULI_CHARS = 'IXYZ'
-PAULI_GATES: List[Union['cirq.Pauli', 'cirq.IdentityGate']] = [
+PAULI_GATES: list[cirq.Pauli | cirq.IdentityGate] = [
     identity.I,
     pauli_gates.X,
     pauli_gates.Y,
@@ -84,9 +81,9 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
     def __init__(
         self,
-        pauli_mask: Union[Iterable['cirq.PAULI_GATE_LIKE'], np.ndarray],
+        pauli_mask: Iterable[cirq.PAULI_GATE_LIKE] | np.ndarray,
         *,
-        coefficient: 'cirq.TParamValComplex' = 1,
+        coefficient: cirq.TParamValComplex = 1,
     ):
         """Initializes a new dense pauli string.
 
@@ -103,7 +100,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
                 values are supported.
         """
         self._pauli_mask = _as_pauli_mask(pauli_mask)
-        self._coefficient: Union[complex, sympy.Expr] = (
+        self._coefficient: complex | sympy.Expr = (
             coefficient if isinstance(coefficient, sympy.Expr) else complex(coefficient)
         )
         if type(self) != MutableDensePauliString:
@@ -116,11 +113,11 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         return self._pauli_mask
 
     @property
-    def coefficient(self) -> 'cirq.TParamValComplex':
+    def coefficient(self) -> cirq.TParamValComplex:
         """A complex coefficient or symbol."""
         return self._coefficient
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['pauli_mask', 'coefficient'])
 
     def _value_equality_values_(self):
@@ -129,7 +126,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         return self.coefficient, tuple(PAULI_CHARS[p] for p in self.pauli_mask)
 
     @classmethod
-    def one_hot(cls, *, index: int, length: int, pauli: 'cirq.PAULI_GATE_LIKE') -> Self:
+    def one_hot(cls, *, index: int, length: int, pauli: cirq.PAULI_GATE_LIKE) -> Self:
         """Creates a dense pauli string with only one non-identity Pauli.
 
         Args:
@@ -163,14 +160,14 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
             return False
         return abs(1 - abs(cast(complex, self.coefficient))) < 1e-8
 
-    def _unitary_(self) -> Union[np.ndarray, NotImplementedType]:
+    def _unitary_(self) -> np.ndarray | NotImplementedType:
         if not self._has_unitary_():
             return NotImplemented
         return self.coefficient * linalg.kron(
             *[protocols.unitary(PAULI_GATES[p]) for p in self.pauli_mask]
         )
 
-    def _apply_unitary_(self, args) -> Union[np.ndarray, None, NotImplementedType]:
+    def _apply_unitary_(self, args) -> np.ndarray | None | NotImplementedType:
         if not self._has_unitary_():
             return NotImplemented
         from cirq import devices
@@ -179,9 +176,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         decomposed_ops = cast(Iterable['cirq.OP_TREE'], self._decompose_(qubits))
         return protocols.apply_unitaries(decomposed_ops, qubits, args)
 
-    def _decompose_(
-        self, qubits: Sequence['cirq.Qid']
-    ) -> Union[NotImplementedType, 'cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> NotImplementedType | cirq.OP_TREE:
         if not self._has_unitary_():
             return NotImplemented
         result = [PAULI_GATES[p].on(q) for p, q in zip(self.pauli_mask, qubits) if p]
@@ -195,7 +190,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     def _parameter_names_(self) -> AbstractSet[str]:
         return protocols.parameter_names(self.coefficient)
 
-    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> Self:
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> Self:
         return self.copy(
             coefficient=protocols.resolve_parameters(self.coefficient, resolver, recursive)
         )
@@ -203,7 +198,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     def __pos__(self):
         return self
 
-    def __pow__(self, power: float) -> Union[NotImplementedType, Self]:
+    def __pow__(self, power: float) -> NotImplementedType | Self:
         concrete_class = type(self)
         if isinstance(power, int):
             i_group = [1, +1j, -1, -1j]
@@ -218,7 +213,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
         return NotImplemented
 
     @overload
-    def __getitem__(self, item: int) -> Union['cirq.Pauli', 'cirq.IdentityGate']:
+    def __getitem__(self, item: int) -> cirq.Pauli | cirq.IdentityGate:
         pass
 
     @overload
@@ -234,7 +229,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
         raise TypeError(f'indices must be integers or slices, not {type(item)}')
 
-    def __iter__(self) -> Iterator[Union['cirq.Pauli', 'cirq.IdentityGate']]:
+    def __iter__(self) -> Iterator[cirq.Pauli | cirq.IdentityGate]:
         for i in range(len(self)):
             yield self[i]
 
@@ -301,7 +296,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
         return NotImplemented
 
-    def tensor_product(self, other: 'BaseDensePauliString') -> Self:
+    def tensor_product(self, other: BaseDensePauliString) -> Self:
         """Concatenates dense pauli strings and multiplies their coefficients.
 
         Args:
@@ -323,10 +318,10 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
             pauli_mask=self.pauli_mask,
         )
 
-    def on(self, *qubits: 'cirq.Qid') -> 'cirq.PauliString':
+    def on(self, *qubits: cirq.Qid) -> cirq.PauliString:
         return self.sparse(qubits)
 
-    def sparse(self, qubits: Optional[Sequence['cirq.Qid']] = None) -> 'cirq.PauliString':
+    def sparse(self, qubits: Sequence[cirq.Qid] | None = None) -> cirq.PauliString:
         """A `cirq.PauliString` version of this dense pauli string.
 
         Args:
@@ -373,9 +368,7 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
             f'coefficient={proper_repr(self.coefficient)})'
         )
 
-    def _commutes_(
-        self, other: Any, *, atol: float = 1e-8
-    ) -> Union[bool, NotImplementedType, None]:
+    def _commutes_(self, other: Any, *, atol: float = 1e-8) -> bool | NotImplementedType | None:
         if isinstance(other, BaseDensePauliString):
             n = min(len(self.pauli_mask), len(other.pauli_mask))
             phase = _vectorized_pauli_mul_phase(self.pauli_mask[:n], other.pauli_mask[:n])
@@ -390,11 +383,11 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
 
         return NotImplemented
 
-    def frozen(self) -> 'DensePauliString':
+    def frozen(self) -> DensePauliString:
         """A `cirq.DensePauliString` with the same contents."""
         return DensePauliString(coefficient=self.coefficient, pauli_mask=self.pauli_mask)
 
-    def mutable_copy(self) -> 'MutableDensePauliString':
+    def mutable_copy(self) -> MutableDensePauliString:
         """A `cirq.MutableDensePauliString` with the same contents."""
         return MutableDensePauliString(
             coefficient=self.coefficient, pauli_mask=np.copy(self.pauli_mask)
@@ -403,8 +396,8 @@ class BaseDensePauliString(raw_types.Gate, metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def copy(
         self,
-        coefficient: Optional['cirq.TParamValComplex'] = None,
-        pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
+        coefficient: cirq.TParamValComplex | None = None,
+        pauli_mask: None | str | Iterable[int] | np.ndarray = None,
     ) -> Self:
         """Returns a copy with possibly modified contents.
 
@@ -454,14 +447,14 @@ class DensePauliString(BaseDensePauliString):
     dense pauli strings, see `cirq.MutableDensePauliString`.
     """
 
-    def frozen(self) -> 'DensePauliString':
+    def frozen(self) -> DensePauliString:
         return self
 
     def copy(
         self,
-        coefficient: Optional['cirq.TParamValComplex'] = None,
-        pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
-    ) -> 'DensePauliString':
+        coefficient: cirq.TParamValComplex | None = None,
+        pauli_mask: None | str | Iterable[int] | np.ndarray = None,
+    ) -> DensePauliString:
         if pauli_mask is None and (coefficient is None or coefficient == self.coefficient):
             return self
         return DensePauliString(
@@ -489,14 +482,12 @@ class MutableDensePauliString(BaseDensePauliString):
     """
 
     @overload
-    def __setitem__(self, key: int, value: 'cirq.PAULI_GATE_LIKE') -> Self:
+    def __setitem__(self, key: int, value: cirq.PAULI_GATE_LIKE) -> Self:
         pass
 
     @overload
     def __setitem__(
-        self,
-        key: slice,
-        value: Union[Iterable['cirq.PAULI_GATE_LIKE'], np.ndarray, BaseDensePauliString],
+        self, key: slice, value: Iterable[cirq.PAULI_GATE_LIKE] | np.ndarray | BaseDensePauliString
     ) -> Self:
         pass
 
@@ -559,9 +550,9 @@ class MutableDensePauliString(BaseDensePauliString):
 
     def copy(
         self,
-        coefficient: Optional['cirq.TParamValComplex'] = None,
-        pauli_mask: Union[None, str, Iterable[int], np.ndarray] = None,
-    ) -> 'MutableDensePauliString':
+        coefficient: cirq.TParamValComplex | None = None,
+        pauli_mask: None | str | Iterable[int] | np.ndarray = None,
+    ) -> MutableDensePauliString:
         return MutableDensePauliString(
             coefficient=self.coefficient if coefficient is None else coefficient,
             pauli_mask=np.copy(self.pauli_mask) if pauli_mask is None else pauli_mask,
@@ -574,7 +565,7 @@ class MutableDensePauliString(BaseDensePauliString):
         return self.coefficient, tuple(PAULI_CHARS[p] for p in self.pauli_mask)
 
     @classmethod
-    def inline_gaussian_elimination(cls, rows: 'List[MutableDensePauliString]') -> None:
+    def inline_gaussian_elimination(cls, rows: list[MutableDensePauliString]) -> None:
         if not rows:
             return
 
@@ -605,7 +596,7 @@ class MutableDensePauliString(BaseDensePauliString):
                 next_row += 1
 
 
-def _pauli_index(val: 'cirq.PAULI_GATE_LIKE') -> int:
+def _pauli_index(val: cirq.PAULI_GATE_LIKE) -> int:
     m = pauli_string.PAULI_GATE_LIKE_TO_INDEX_MAP
     if val not in m:
         raise TypeError(
@@ -616,13 +607,13 @@ def _pauli_index(val: 'cirq.PAULI_GATE_LIKE') -> int:
     return m[val]
 
 
-def _as_pauli_mask(val: Union[Iterable['cirq.PAULI_GATE_LIKE'], np.ndarray]) -> np.ndarray:
+def _as_pauli_mask(val: Iterable[cirq.PAULI_GATE_LIKE] | np.ndarray) -> np.ndarray:
     if isinstance(val, np.ndarray):
         return np.asarray(val, dtype=np.uint8)
     return np.array([_pauli_index(v) for v in val], dtype=np.uint8)
 
 
-def _attempt_value_to_pauli_index(v: 'cirq.Operation') -> Optional[Tuple[int, int]]:
+def _attempt_value_to_pauli_index(v: cirq.Operation) -> tuple[int, int] | None:
     if not isinstance(v, raw_types.Operation):
         return None
 
@@ -641,9 +632,7 @@ def _attempt_value_to_pauli_index(v: 'cirq.Operation') -> Optional[Tuple[int, in
     return pauli_string.PAULI_GATE_LIKE_TO_INDEX_MAP[v.gate], q.x
 
 
-def _vectorized_pauli_mul_phase(
-    lhs: Union[int, np.ndarray], rhs: Union[int, np.ndarray]
-) -> complex:
+def _vectorized_pauli_mul_phase(lhs: int | np.ndarray, rhs: int | np.ndarray) -> complex:
     """Computes the leading coefficient of a pauli string multiplication.
 
     The two inputs must have the same length. They must follow the convention

cirq/ops/dense_pauli_string_test.py

@@ -11,8 +11,10 @@
 # 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 numbers
-from typing import List
 
 import numpy as np
 import pytest
@@ -544,7 +546,7 @@ def test_copy():
 
 
 def test_gaussian_elimination():
-    def table(*rows: str) -> List[cirq.MutableDensePauliString]:
+    def table(*rows: str) -> list[cirq.MutableDensePauliString]:
         coefs = {'i': 1j, '-': -1, '+': 1}
         return [
             cirq.MutableDensePauliString(row[1:].replace('.', 'I'), coefficient=coefs[row[0]])

cirq/ops/diagonal_gate.py

@@ -18,18 +18,9 @@ The gate is used to create a (2^n)x(2^n) matrix with the diagonal elements
 passed as a list.
 """
 
-from typing import (
-    AbstractSet,
-    Any,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from __future__ import annotations
+
+from typing import AbstractSet, Any, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -42,7 +33,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _fast_walsh_hadamard_transform(a: Tuple[Any, ...]) -> np.ndarray:
+def _fast_walsh_hadamard_transform(a: tuple[Any, ...]) -> np.ndarray:
     """Fast Walsh–Hadamard Transform of an array."""
     h = 1
     a_ = np.array(a)
@@ -57,7 +48,7 @@ def _fast_walsh_hadamard_transform(a: Tuple[Any, ...]) -> np.ndarray:
     return a_
 
 
-def _gen_gray_code(n: int) -> Iterator[Tuple[int, int]]:
+def _gen_gray_code(n: int) -> Iterator[tuple[int, int]]:
     """Generate the Gray Code from 0 to 2^n-1.
 
     Each iteration yields a two-tuple, `(gray_code, bit_flip)`. `gray_code` is the decimal
@@ -81,7 +72,7 @@ class DiagonalGate(raw_types.Gate):
     all phases.
     """
 
-    def __init__(self, diag_angles_radians: Sequence['cirq.TParamVal']) -> None:
+    def __init__(self, diag_angles_radians: Sequence[cirq.TParamVal]) -> None:
         r"""A n-qubit gate with only diagonal elements.
 
         This gate's off-diagonal elements are zero and its on-diagonal
@@ -92,10 +83,10 @@ class DiagonalGate(raw_types.Gate):
                 If these values are $(x_0, x_1, \ldots , x_N)$ then the unitary
                 has diagonal values $(e^{i x_0}, e^{i x_1}, \ldots, e^{i x_N})$.
         """
-        self._diag_angles_radians: Tuple['cirq.TParamVal', ...] = tuple(diag_angles_radians)
+        self._diag_angles_radians: tuple[cirq.TParamVal, ...] = tuple(diag_angles_radians)
 
     @property
-    def diag_angles_radians(self) -> Tuple['cirq.TParamVal', ...]:
+    def diag_angles_radians(self) -> tuple[cirq.TParamVal, ...]:
         return self._diag_angles_radians
 
     def _num_qubits_(self):
@@ -109,9 +100,7 @@ class DiagonalGate(raw_types.Gate):
             name for angle in self._diag_angles_radians for name in protocols.parameter_names(angle)
         }
 
-    def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'DiagonalGate':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> DiagonalGate:
         return DiagonalGate(
             protocols.resolve_parameters(self._diag_angles_radians, resolver, recursive)
         )
@@ -119,12 +108,12 @@ class DiagonalGate(raw_types.Gate):
     def _has_unitary_(self) -> bool:
         return not self._is_parameterized_()
 
-    def _unitary_(self) -> Optional[np.ndarray]:
+    def _unitary_(self) -> np.ndarray | None:
         if self._is_parameterized_():
             return None
         return np.diag([np.exp(1j * angle) for angle in self._diag_angles_radians])
 
-    def _apply_unitary_(self, args: 'protocols.ApplyUnitaryArgs') -> np.ndarray:
+    def _apply_unitary_(self, args: protocols.ApplyUnitaryArgs) -> np.ndarray:
         if self._is_parameterized_():
             return NotImplemented
         for index, angle in enumerate(self._diag_angles_radians):
@@ -132,9 +121,7 @@ class DiagonalGate(raw_types.Gate):
             args.target_tensor[subspace_index] *= np.exp(1j * angle)
         return args.target_tensor
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         rounded_angles = np.array(self._diag_angles_radians)
         if args.precision is not None:
             rounded_angles = rounded_angles.round(args.precision)
@@ -150,7 +137,7 @@ class DiagonalGate(raw_types.Gate):
             [diag_str] + [f"#{i}" for i in range(2, self._num_qubits_() + 1)]
         )
 
-    def __pow__(self, exponent: Any) -> 'DiagonalGate':
+    def __pow__(self, exponent: Any) -> DiagonalGate:
         if not isinstance(exponent, (int, float, sympy.Basic)):
             return NotImplemented
         angles = []
@@ -163,8 +150,8 @@ class DiagonalGate(raw_types.Gate):
         return tuple(self._diag_angles_radians)
 
     def _decompose_for_basis(
-        self, index: int, bit_flip: int, theta: 'cirq.TParamVal', qubits: Sequence['cirq.Qid']
-    ) -> Iterator[Union['cirq.ZPowGate', 'cirq.CXPowGate']]:
+        self, index: int, bit_flip: int, theta: cirq.TParamVal, qubits: Sequence[cirq.Qid]
+    ) -> Iterator[cirq.ZPowGate | cirq.CXPowGate]:
         if index == 0:
             return
         largest_digit = self._num_qubits_() - (len(bin(index)) - 2)
@@ -175,7 +162,7 @@ class DiagonalGate(raw_types.Gate):
         elif _flip_bit > largest_digit:
             yield common_gates.CNOT(qubits[_flip_bit], qubits[largest_digit])
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         """Decompose the n-qubit diagonal gates into CNOT and Rz gates.
 
         A 3 qubits decomposition looks like
@@ -202,14 +189,14 @@ class DiagonalGate(raw_types.Gate):
         # decomposed gates. On its own it is not physically observable. However, if using this
         # diagonal gate for sub-system like controlled gate, it is no longer equivalent. Hence,
         # we add global phase.
-        decomposed_circ: List[Any] = [
+        decomposed_circ: list[Any] = [
             global_phase_op.global_phase_operation(1j ** (2 * hat_angles[0] / np.pi))
         ]
         for i, bit_flip in _gen_gray_code(n):
             decomposed_circ.extend(self._decompose_for_basis(i, bit_flip, -hat_angles[i], qubits))
         return decomposed_circ
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, attribute_names=["diag_angles_radians"])
 
     def __repr__(self) -> str:

cirq/ops/diagonal_gate_test.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List
+from __future__ import annotations
 
 import numpy as np
 import pytest
@@ -20,7 +20,7 @@ import sympy
 
 import cirq
 
-_candidate_angles: List[float] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53]
+_candidate_angles: list[float] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53]
 
 
 @pytest.mark.parametrize(
@@ -36,18 +36,18 @@ _candidate_angles: List[float] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41
         )
     ),
 )
-def test_consistent_protocols(gate):
+def test_consistent_protocols(gate) -> None:
     cirq.testing.assert_implements_consistent_protocols(gate)
 
 
-def test_property():
+def test_property() -> None:
     assert cirq.DiagonalGate([2, 3, 5, 7]).diag_angles_radians == (2, 3, 5, 7)
 
 
 @pytest.mark.parametrize('n', [1, 2, 3, 4, 5, 6, 7, 8, 9])
-def test_decomposition_unitary(n):
+def test_decomposition_unitary(n) -> None:
     diagonal_angles = np.random.randn(2**n)
-    diagonal_gate = cirq.DiagonalGate(diagonal_angles)
+    diagonal_gate = cirq.DiagonalGate(list(diagonal_angles))
     decomposed_circ = cirq.Circuit(cirq.decompose(diagonal_gate(*cirq.LineQubit.range(n))))
 
     expected_f = [np.exp(1j * angle) for angle in diagonal_angles]
@@ -59,7 +59,7 @@ def test_decomposition_unitary(n):
 
 
 @pytest.mark.parametrize('n', [1, 2, 3, 4])
-def test_diagonal_exponent(n):
+def test_diagonal_exponent(n) -> None:
     diagonal_angles = _candidate_angles[: 2**n]
     diagonal_gate = cirq.DiagonalGate(diagonal_angles)
 
@@ -72,9 +72,9 @@ def test_diagonal_exponent(n):
 
 
 @pytest.mark.parametrize('n', [1, 2, 3, 4])
-def test_decomposition_diagonal_exponent(n):
+def test_decomposition_diagonal_exponent(n) -> None:
     diagonal_angles = np.random.randn(2**n)
-    diagonal_gate = cirq.DiagonalGate(diagonal_angles)
+    diagonal_gate = cirq.DiagonalGate(list(diagonal_angles))
     sqrt_diagonal_gate = diagonal_gate**0.5
     decomposed_circ = cirq.Circuit(cirq.decompose(sqrt_diagonal_gate(*cirq.LineQubit.range(n))))
 
@@ -85,7 +85,7 @@ def test_decomposition_diagonal_exponent(n):
 
 
 @pytest.mark.parametrize('n', [1, 2, 3, 4])
-def test_decomposition_with_parameterization(n):
+def test_decomposition_with_parameterization(n) -> None:
     angles = sympy.symbols([f'x_{i}' for i in range(2**n)])
     exponent = sympy.Symbol('e')
     diagonal_gate = cirq.DiagonalGate(angles) ** exponent
@@ -104,7 +104,7 @@ def test_decomposition_with_parameterization(n):
             )
 
 
-def test_diagram():
+def test_diagram() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
 
     diagonal_circuit = cirq.Circuit(cirq.DiagonalGate(_candidate_angles[:16])(a, b, c, d))
@@ -145,7 +145,7 @@ def test_diagram():
 
 
 @pytest.mark.parametrize('n', [1, 2, 3, 4])
-def test_unitary(n):
+def test_unitary(n) -> None:
     diagonal_angles = _candidate_angles[: 2**n]
     assert cirq.has_unitary(cirq.DiagonalGate(diagonal_angles))
     np.testing.assert_allclose(
@@ -156,7 +156,7 @@ def test_unitary(n):
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve(resolve_fn):
+def test_resolve(resolve_fn) -> None:
     diagonal_angles = [2, 3, 5, 7, 11, 13, 17, 19]
     diagonal_gate = cirq.DiagonalGate(diagonal_angles[:6] + [sympy.Symbol('a'), sympy.Symbol('b')])
     assert cirq.is_parameterized(diagonal_gate)