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

cirq/qis/channels_test.py

@@ -11,7 +11,11 @@
 # 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.
+
 """Tests for channels."""
+
+from __future__ import annotations
+
 from typing import Iterable, Sequence
 
 import numpy as np
@@ -65,7 +69,7 @@ def compute_choi(channel: cirq.SupportsKraus) -> np.ndarray:
         ),
     ),
 )
-def test_kraus_to_choi(kraus_operators, expected_choi):
+def test_kraus_to_choi(kraus_operators, expected_choi) -> None:
     """Verifies that cirq.kraus_to_choi computes the correct Choi matrix."""
     assert np.allclose(cirq.kraus_to_choi(kraus_operators), expected_choi)
 
@@ -89,7 +93,7 @@ def test_kraus_to_choi(kraus_operators, expected_choi):
         ),
     ),
 )
-def test_choi_to_kraus_invalid_input(choi, error):
+def test_choi_to_kraus_invalid_input(choi, error) -> None:
     with pytest.raises(ValueError, match=error):
         _ = cirq.choi_to_kraus(choi)
 
@@ -143,7 +147,7 @@ def test_choi_to_kraus_invalid_input(choi, error):
         ),
     ),
 )
-def test_choi_to_kraus_fixed_values(choi, expected_kraus):
+def test_choi_to_kraus_fixed_values(choi, expected_kraus) -> None:
     """Verifies that cirq.choi_to_kraus gives correct results on a few fixed inputs."""
     actual_kraus = cirq.choi_to_kraus(choi)
     assert len(actual_kraus) == len(expected_kraus)
@@ -178,7 +182,7 @@ def test_choi_to_kraus_fixed_values(choi, expected_kraus):
         ),
     ),
 )
-def test_choi_to_kraus_action_on_operatorial_basis(choi):
+def test_choi_to_kraus_action_on_operatorial_basis(choi) -> None:
     """Verifies that cirq.choi_to_kraus computes a valid Kraus representation."""
     kraus_operators = cirq.choi_to_kraus(choi)
     c = np.reshape(choi, (2, 2, 2, 2))
@@ -217,14 +221,14 @@ def test_choi_to_kraus_action_on_operatorial_basis(choi):
         # fmt: on
     ),
 )
-def test_choi_to_kraus_inverse_of_kraus_to_choi(choi):
+def test_choi_to_kraus_inverse_of_kraus_to_choi(choi) -> None:
     """Verifies that cirq.kraus_to_choi(cirq.choi_to_kraus(.)) is identity on Choi matrices."""
     kraus = cirq.choi_to_kraus(choi)
     recovered_choi = cirq.kraus_to_choi(kraus)
     assert np.allclose(recovered_choi, choi)
 
 
-def test_choi_to_kraus_atol():
+def test_choi_to_kraus_atol() -> None:
     """Verifies that insignificant Kraus operators are omitted."""
     choi = cirq.kraus_to_choi(cirq.kraus(cirq.phase_damp(1e-6)))
     assert len(cirq.choi_to_kraus(choi, atol=1e-2)) == 1
@@ -242,7 +246,7 @@ def test_choi_to_kraus_atol():
         cirq.amplitude_damp(0.2),
     ),
 )
-def test_operation_to_choi(channel):
+def test_operation_to_choi(channel) -> None:
     """Verifies that cirq.operation_to_choi correctly computes the Choi matrix."""
     n_qubits = cirq.num_qubits(channel)
     actual = cirq.operation_to_choi(channel)
@@ -251,7 +255,7 @@ def test_operation_to_choi(channel):
     assert np.all(actual == expected)
 
 
-def test_choi_for_completely_dephasing_channel():
+def test_choi_for_completely_dephasing_channel() -> None:
     """Checks cirq.operation_to_choi on the completely dephasing channel."""
     assert np.all(cirq.operation_to_choi(cirq.phase_damp(1)) == np.diag([1, 0, 0, 1]))
 
@@ -268,7 +272,7 @@ def test_choi_for_completely_dephasing_channel():
         ),
     ),
 )
-def test_superoperator_to_kraus_fixed_values(superoperator, expected_kraus_operators):
+def test_superoperator_to_kraus_fixed_values(superoperator, expected_kraus_operators) -> None:
     """Verifies that cirq.kraus_to_superoperator computes the correct channel matrix."""
     actual_kraus_operators = cirq.superoperator_to_kraus(superoperator)
     for i in (0, 1):
@@ -306,14 +310,14 @@ def test_superoperator_to_kraus_fixed_values(superoperator, expected_kraus_opera
         # fmt: on
     ),
 )
-def test_superoperator_to_kraus_inverse_of_kraus_to_superoperator(superoperator):
+def test_superoperator_to_kraus_inverse_of_kraus_to_superoperator(superoperator) -> None:
     """Verifies that cirq.kraus_to_superoperator(cirq.superoperator_to_kraus(.)) is identity."""
     kraus = cirq.superoperator_to_kraus(superoperator)
     recovered_superoperator = cirq.kraus_to_superoperator(kraus)
     assert np.allclose(recovered_superoperator, superoperator)
 
 
-def test_superoperator_to_kraus_atol():
+def test_superoperator_to_kraus_atol() -> None:
     """Verifies that insignificant Kraus operators are omitted."""
     superop = cirq.kraus_to_superoperator(cirq.kraus(cirq.phase_damp(1e-6)))
     assert len(cirq.superoperator_to_kraus(superop, atol=1e-2)) == 1
@@ -338,7 +342,7 @@ def test_superoperator_to_kraus_atol():
         ),
     ),
 )
-def test_choi_to_superoperator_invalid_input(choi, error):
+def test_choi_to_superoperator_invalid_input(choi, error) -> None:
     with pytest.raises(ValueError, match=error):
         _ = cirq.choi_to_superoperator(choi)
 
@@ -346,7 +350,7 @@ def test_choi_to_superoperator_invalid_input(choi, error):
 @pytest.mark.parametrize(
     'superoperator, error', ((np.array([[1, 2, 3], [4, 5, 6]]), "shape"), (np.eye(2), "shape"))
 )
-def test_superoperator_to_choi_invalid_input(superoperator, error):
+def test_superoperator_to_choi_invalid_input(superoperator, error) -> None:
     with pytest.raises(ValueError, match=error):
         _ = cirq.superoperator_to_choi(superoperator)
 
@@ -402,7 +406,7 @@ def test_superoperator_to_choi_invalid_input(superoperator, error):
         ),
     ),
 )
-def test_superoperator_vs_choi_fixed_values(superoperator, choi):
+def test_superoperator_vs_choi_fixed_values(superoperator, choi) -> None:
     recovered_choi = cirq.superoperator_to_choi(superoperator)
     assert np.allclose(recovered_choi, choi)
 
@@ -436,7 +440,7 @@ def test_superoperator_vs_choi_fixed_values(superoperator, choi):
         # fmt: on
     ),
 )
-def test_choi_to_superoperator_inverse_of_superoperator_to_choi(choi):
+def test_choi_to_superoperator_inverse_of_superoperator_to_choi(choi) -> None:
     superoperator = cirq.choi_to_superoperator(choi)
     recovered_choi = cirq.superoperator_to_choi(superoperator)
     assert np.allclose(recovered_choi, choi)
@@ -445,6 +449,6 @@ def test_choi_to_superoperator_inverse_of_superoperator_to_choi(choi):
     assert np.allclose(recovered_superoperator, superoperator)
 
 
-def test_superoperator_for_completely_dephasing_channel():
+def test_superoperator_for_completely_dephasing_channel() -> None:
     """Checks cirq.operation_to_superoperator on the completely dephasing channel."""
     assert np.all(cirq.operation_to_superoperator(cirq.phase_damp(1)) == np.diag([1, 0, 0, 1]))

cirq/qis/clifford_tableau.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
-from typing import Any, Dict, List, Optional, Sequence, TYPE_CHECKING
+from typing import Any, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -145,9 +147,9 @@ class CliffordTableau(StabilizerState):
         self,
         num_qubits,
         initial_state: int = 0,
-        rs: Optional[np.ndarray] = None,
-        xs: Optional[np.ndarray] = None,
-        zs: Optional[np.ndarray] = None,
+        rs: np.ndarray | None = None,
+        xs: np.ndarray | None = None,
+        zs: np.ndarray | None = None,
     ):
         """Initializes CliffordTableau
         Args:
@@ -164,7 +166,7 @@ class CliffordTableau(StabilizerState):
         self._xs = self._reconstruct_xs(xs)
         self._zs = self._reconstruct_zs(zs)
 
-    def _reconstruct_rs(self, rs: Optional[np.ndarray]) -> np.ndarray:
+    def _reconstruct_rs(self, rs: np.ndarray | None) -> np.ndarray:
         if rs is None:
             new_rs = np.zeros(2 * self.n + 1, dtype=bool)
             for i, val in enumerate(
@@ -183,7 +185,7 @@ class CliffordTableau(StabilizerState):
                 )
         return new_rs
 
-    def _reconstruct_xs(self, xs: Optional[np.ndarray]) -> np.ndarray:
+    def _reconstruct_xs(self, xs: np.ndarray | None) -> np.ndarray:
         if xs is None:
             new_xs = np.zeros((2 * self.n + 1, self.n), dtype=bool)
             for i in range(self.n):
@@ -205,7 +207,7 @@ class CliffordTableau(StabilizerState):
                 )
         return new_xs
 
-    def _reconstruct_zs(self, zs: Optional[np.ndarray]) -> np.ndarray:
+    def _reconstruct_zs(self, zs: np.ndarray | None) -> np.ndarray:
         if zs is None:
             new_zs = np.zeros((2 * self.n + 1, self.n), dtype=bool)
             for i in range(self.n):
@@ -258,7 +260,7 @@ class CliffordTableau(StabilizerState):
         """Returns the 2n * 2n matrix representation of the Clifford tableau."""
         return np.concatenate([self.xs, self.zs], axis=1)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['n', 'rs', 'xs', 'zs'])
 
     @classmethod
@@ -286,10 +288,10 @@ class CliffordTableau(StabilizerState):
             and np.array_equal(self.zs, other.zs)
         )
 
-    def __copy__(self) -> 'CliffordTableau':
+    def __copy__(self) -> CliffordTableau:
         return self.copy()
 
-    def copy(self, deep_copy_buffers: bool = True) -> 'CliffordTableau':
+    def copy(self, deep_copy_buffers: bool = True) -> CliffordTableau:
         state = CliffordTableau(self.n)
         state.rs = self.rs.copy()
         state.xs = self.xs.copy()
@@ -364,7 +366,7 @@ class CliffordTableau(StabilizerState):
 
         return '\n'.join([title_row, divider, *contents]) + '\n'
 
-    def then(self, second: 'CliffordTableau') -> 'CliffordTableau':
+    def then(self, second: CliffordTableau) -> CliffordTableau:
         """Returns a composed CliffordTableau of this tableau and the second tableau.
 
         Then composed tableau is equal to (up to global phase) the composed
@@ -431,7 +433,7 @@ class CliffordTableau(StabilizerState):
 
         return merged_tableau
 
-    def inverse(self) -> 'CliffordTableau':
+    def inverse(self) -> CliffordTableau:
         """Returns the inverse Clifford tableau of this tableau."""
         ret_table = CliffordTableau(num_qubits=self.n)
         # It relies on the symplectic property of Clifford tableau.
@@ -450,7 +452,7 @@ class CliffordTableau(StabilizerState):
         ret_table.rs = ret_table.then(self).rs
         return ret_table
 
-    def __matmul__(self, second: 'CliffordTableau'):
+    def __matmul__(self, second: CliffordTableau):
         if not isinstance(second, CliffordTableau):
             return NotImplemented
         return second.then(self)
@@ -481,7 +483,7 @@ class CliffordTableau(StabilizerState):
         self._xs[q1, :] ^= self._xs[q2, :]
         self._zs[q1, :] ^= self._zs[q2, :]
 
-    def _row_to_dense_pauli(self, i: int) -> 'cirq.DensePauliString':
+    def _row_to_dense_pauli(self, i: int) -> cirq.DensePauliString:
         """Return a dense Pauli string for the given row in the tableau.
 
         Args:
@@ -509,12 +511,12 @@ class CliffordTableau(StabilizerState):
                 pauli_mask += "I"
         return DensePauliString(pauli_mask, coefficient=coefficient)
 
-    def stabilizers(self) -> List['cirq.DensePauliString']:
+    def stabilizers(self) -> list[cirq.DensePauliString]:
         """Returns the stabilizer generators of the state. These
         are n operators {S_1,S_2,...,S_n} such that S_i |psi> = |psi>"""
         return [self._row_to_dense_pauli(i) for i in range(self.n, 2 * self.n)]
 
-    def destabilizers(self) -> List['cirq.DensePauliString']:
+    def destabilizers(self) -> list[cirq.DensePauliString]:
         """Returns the destabilizer generators of the state. These
         are n operators {S_1,S_2,...,S_n} such that along with the stabilizer
         generators above generate the full Pauli group on n qubits."""
@@ -662,15 +664,15 @@ class CliffordTableau(StabilizerState):
         pass
 
     def measure(
-        self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
-    ) -> List[int]:
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
+    ) -> list[int]:
         return [self._measure(axis, random_state.parse_random_state(seed)) for axis in axes]
 
     @cached_method
     def __hash__(self) -> int:
         return hash(self.matrix().tobytes() + self.rs.tobytes())
 
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         # clear cached hash value when pickling, see #6674
         state = self.__dict__
         hash_attr = _method_cache_name(self.__hash__)

cirq/qis/clifford_tableau_test.py

@@ -14,6 +14,8 @@
 
 """Tests for clifford tableau."""
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 
@@ -438,9 +440,7 @@ def test_tableau_matmul():
     assert expected_t != t1 @ t2
 
     with pytest.raises(TypeError):
-        # pylint: disable=pointless-statement
         t1 @ 21
-        # pylint: enable=pointless-statement
 
 
 def test_tableau_then_with_bad_input():

cirq/qis/entropy.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from collections.abc import Sequence
 from concurrent.futures import ThreadPoolExecutor
 from itertools import product
-from typing import Any, Optional
+from typing import Any, cast, Iterator
 
 import numpy as np
 import numpy.typing as npt
@@ -73,8 +75,17 @@ def _compute_bitstrings_contribution_to_purity(bitstrings: npt.NDArray[np.int8])
     """
 
     bitstrings, probs = _bitstrings_to_probs(bitstrings)
+    product_iterator = cast(
+        Iterator[
+            tuple[
+                tuple[npt.NDArray[np.int8], npt.NDArray[Any]],
+                tuple[npt.NDArray[np.int8], npt.NDArray[Any]],
+            ]
+        ],
+        product(zip(bitstrings, probs), repeat=2),
+    )
     purity = 0
-    for (s, p), (s_prime, p_prime) in product(zip(bitstrings, probs), repeat=2):
+    for (s, p), (s_prime, p_prime) in product_iterator:
         purity += (-2.0) ** float(-_get_hamming_distance(s, s_prime)) * p * p_prime
 
     return purity * 2 ** (bitstrings.shape[-1])
@@ -83,7 +94,7 @@ def _compute_bitstrings_contribution_to_purity(bitstrings: npt.NDArray[np.int8])
 def process_renyi_entropy_from_bitstrings(
     measured_bitstrings: npt.NDArray[np.int8],
     subsystem: tuple[int] | None = None,
-    pool: Optional[ThreadPoolExecutor] = None,
+    pool: ThreadPoolExecutor | None = None,
 ) -> float:
     """Compute the Rényi entropy of an array of bitstrings.
     Args:

cirq/qis/entropy_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 concurrent.futures import ThreadPoolExecutor
 
 import numpy as np
@@ -36,7 +38,7 @@ def test_process_renyi_entropy_from_bitstrings(pool):
     assert entropy == 0.5145731728297583
 
 
-def test_process_renyi_entropy_from_bitstrings_safeguards_against_divide_by_0_error():
+def test_process_renyi_entropy_from_bitstrings_safeguards_against_divide_by_0_error() -> None:
     bitstrings = np.array([[[0, 1, 1, 0]], [[0, 1, 1, 0]], [[0, 0, 1, 1]]])
 
     entropy = process_renyi_entropy_from_bitstrings(bitstrings)

cirq/qis/measures.py

@@ -11,10 +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.
+
 """Measures on and between quantum states and operations."""
 
+from __future__ import annotations
 
-from typing import Optional, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -42,7 +44,7 @@ def _sqrt_positive_semidefinite_matrix(mat: np.ndarray) -> np.ndarray:
     return vecs @ (np.sqrt(np.abs(eigs)) * vecs).T.conj()
 
 
-def _validate_int_state(state: int, qid_shape: Optional[Tuple[int, ...]]) -> None:
+def _validate_int_state(state: int, qid_shape: tuple[int, ...] | None) -> None:
     if state < 0:
         raise ValueError(
             'Invalid state: A state specified as an integer must be non-negative, '
@@ -58,9 +60,7 @@ def _validate_int_state(state: int, qid_shape: Optional[Tuple[int, ...]]) -> Non
             )
 
 
-def _validate_product_state(
-    state: 'cirq.ProductState', qid_shape: Optional[Tuple[int, ...]]
-) -> None:
+def _validate_product_state(state: cirq.ProductState, qid_shape: tuple[int, ...] | None) -> None:
     if qid_shape is not None and qid_shape != (2,) * len(state):
         raise ValueError(
             'Invalid state for given qid shape: '
@@ -70,9 +70,9 @@ def _validate_product_state(
 
 
 def fidelity(
-    state1: 'cirq.QUANTUM_STATE_LIKE',
-    state2: 'cirq.QUANTUM_STATE_LIKE',
-    qid_shape: Optional[Tuple[int, ...]] = None,
+    state1: cirq.QUANTUM_STATE_LIKE,
+    state2: cirq.QUANTUM_STATE_LIKE,
+    qid_shape: tuple[int, ...] | None = None,
     validate: bool = True,
     atol: float = 1e-7,
 ) -> float:
@@ -156,10 +156,10 @@ def fidelity(
 def _numpy_arrays_to_state_vectors_or_density_matrices(
     state1: np.ndarray,
     state2: np.ndarray,
-    qid_shape: Optional[Tuple[int, ...]],
+    qid_shape: tuple[int, ...] | None,
     validate: bool,
     atol: float,
-) -> Tuple[np.ndarray, np.ndarray]:
+) -> tuple[np.ndarray, np.ndarray]:
     if state1.ndim > 2 or (state1.ndim == 2 and state1.shape[0] != state1.shape[1]):
         # State tensor, convert to state vector
         state1 = state1.reshape(-1)
@@ -255,8 +255,8 @@ def _fidelity_state_vectors_or_density_matrices(state1: np.ndarray, state2: np.n
 
 
 def von_neumann_entropy(
-    state: 'cirq.QUANTUM_STATE_LIKE',
-    qid_shape: Optional[Tuple[int, ...]] = None,
+    state: cirq.QUANTUM_STATE_LIKE,
+    qid_shape: tuple[int, ...] | None = None,
     validate: bool = True,
     atol: float = 1e-7,
 ) -> float:
@@ -298,7 +298,7 @@ def von_neumann_entropy(
     return 0.0
 
 
-def entanglement_fidelity(operation: 'cirq.SupportsKraus') -> float:
+def entanglement_fidelity(operation: cirq.SupportsKraus) -> float:
     r"""Returns entanglement fidelity of a given quantum channel.
 
     Entanglement fidelity $F_e$ of a quantum channel $E: L(H) \to L(H)$ is the overlap between

cirq/qis/measures_test.py

@@ -11,7 +11,11 @@
 # 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.
+
 """Tests for measures."""
+
+from __future__ import annotations
+
 import numpy as np
 import pytest
 
@@ -25,7 +29,7 @@ MAT2 = cirq.testing.random_density_matrix(N)
 U = cirq.testing.random_unitary(N)
 
 
-def test_fidelity_symmetric():
+def test_fidelity_symmetric() -> None:
     np.testing.assert_allclose(cirq.fidelity(VEC1, VEC2), cirq.fidelity(VEC2, VEC1))
     np.testing.assert_allclose(cirq.fidelity(VEC1, MAT1), cirq.fidelity(MAT1, VEC1))
     np.testing.assert_allclose(
@@ -34,27 +38,27 @@ def test_fidelity_symmetric():
     )
 
 
-def test_bad_fidelity():
+def test_bad_fidelity() -> None:
     arr = np.asarray([[[1j, 0], [0, 0]], [[0, 0], [0, 0]]])
     assert arr.ndim > 2
     assert arr.dtype.kind == 'c'
     _ = cirq.fidelity(arr, arr)
 
 
-def test_fidelity_between_zero_and_one():
+def test_fidelity_between_zero_and_one() -> None:
     assert 0 <= cirq.fidelity(VEC1, VEC2) <= 1
     assert 0 <= cirq.fidelity(VEC1, MAT1) <= 1
     assert 0 <= cirq.fidelity(cirq.density_matrix(MAT1), MAT2) <= 1
 
 
-def test_fidelity_invariant_under_unitary_transformation():
+def test_fidelity_invariant_under_unitary_transformation() -> None:
     np.testing.assert_allclose(
         cirq.fidelity(cirq.density_matrix(MAT1), MAT2),
         cirq.fidelity(cirq.density_matrix(U @ MAT1 @ U.T.conj()), U @ MAT2 @ U.T.conj()),
     )
 
 
-def test_fidelity_commuting_matrices():
+def test_fidelity_commuting_matrices() -> None:
     d1 = np.random.uniform(size=N)
     d1 /= np.sum(d1)
     d2 = np.random.uniform(size=N)
@@ -67,7 +71,7 @@ def test_fidelity_commuting_matrices():
     )
 
 
-def test_fidelity_known_values():
+def test_fidelity_known_values() -> None:
     vec1 = np.array([1, 1j, -1, -1j]) * 0.5
     vec2 = np.array([1, -1, 1, -1], dtype=np.complex128) * 0.5
     vec3 = np.array([1, 0, 0, 0], dtype=np.complex128)
@@ -94,7 +98,7 @@ def test_fidelity_known_values():
     np.testing.assert_allclose(cirq.fidelity(mat3, vec2), 0.7)
 
 
-def test_fidelity_numpy_arrays():
+def test_fidelity_numpy_arrays() -> None:
     vec1 = np.array([1, 0, 0, 0, 0, 0, 0, 0], dtype=np.complex64)
     vec2 = np.array([1, 0, 0, 0], dtype=np.complex64)
     tensor1 = np.reshape(vec1, (2, 2, 2))
@@ -122,7 +126,7 @@ def test_fidelity_numpy_arrays():
         _ = cirq.fidelity(mat1, mat1)
 
 
-def test_fidelity_ints():
+def test_fidelity_ints() -> None:
     assert cirq.fidelity(3, 4) == 0.0
     assert cirq.fidelity(4, 4) == 1.0
 
@@ -134,7 +138,7 @@ def test_fidelity_ints():
         _ = cirq.fidelity(1, 4, qid_shape=(2,))
 
 
-def test_fidelity_product_states():
+def test_fidelity_product_states() -> None:
     a, b = cirq.LineQubit.range(2)
 
     np.testing.assert_allclose(
@@ -171,19 +175,19 @@ def test_fidelity_product_states():
         )
 
 
-def test_fidelity_fail_inference():
+def test_fidelity_fail_inference() -> None:
     state_vector = cirq.one_hot(shape=(4,), dtype=np.complex128)
     state_tensor = np.reshape(state_vector, (2, 2))
     with pytest.raises(ValueError, match='Please specify'):
         _ = cirq.fidelity(state_tensor, 4)
 
 
-def test_fidelity_bad_shape():
+def test_fidelity_bad_shape() -> None:
     with pytest.raises(ValueError, match='Invalid quantum state'):
         _ = cirq.fidelity(np.array([[[1.0]]]), np.array([[[1.0]]]), qid_shape=(1,))
 
 
-def test_von_neumann_entropy():
+def test_von_neumann_entropy() -> None:
     # 1x1 matrix
     assert cirq.von_neumann_entropy(np.array([[1]])) == 0
     # An EPR pair state (|00> + |11>)(<00| + <11|)
@@ -243,7 +247,7 @@ def test_von_neumann_entropy():
         (cirq.TOFFOLI, 9 / 16),
     ),
 )
-def test_entanglement_fidelity_of_unitary_channels(gate, expected_entanglement_fidelity):
+def test_entanglement_fidelity_of_unitary_channels(gate, expected_entanglement_fidelity) -> None:
     assert np.isclose(cirq.entanglement_fidelity(gate), expected_entanglement_fidelity)
 
 
@@ -261,7 +265,9 @@ def test_entanglement_fidelity_of_unitary_channels(gate, expected_entanglement_f
         (cirq.amplitude_damp, lambda gamma: 1 / 2 - gamma / 4 + np.sqrt(1 - gamma) / 2),
     ),
 )
-def test_entanglement_fidelity_of_noisy_channels(p, channel_factory, entanglement_fidelity_formula):
+def test_entanglement_fidelity_of_noisy_channels(
+    p, channel_factory, entanglement_fidelity_formula
+) -> None:
     channel = channel_factory(p)
     actual_entanglement_fidelity = cirq.entanglement_fidelity(channel)
     expected_entanglement_fidelity = entanglement_fidelity_formula(p)

cirq/qis/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
+
 import numpy as np
 
 

cirq/qis/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 numpy as np
 import pytest
 
@@ -30,7 +32,7 @@ from cirq.qis.noise_utils import (
     'decay_constant,num_qubits,expected_output',
     [(0.01, 1, 1 - (0.99 * 1 / 2)), (0.05, 2, 1 - (0.95 * 3 / 4))],
 )
-def test_decay_constant_to_xeb_fidelity(decay_constant, num_qubits, expected_output):
+def test_decay_constant_to_xeb_fidelity(decay_constant, num_qubits, expected_output) -> None:
     val = decay_constant_to_xeb_fidelity(decay_constant, num_qubits)
     assert val == expected_output
 
@@ -39,7 +41,7 @@ def test_decay_constant_to_xeb_fidelity(decay_constant, num_qubits, expected_out
     'decay_constant,num_qubits,expected_output',
     [(0.01, 1, 0.99 * 3 / 4), (0.05, 2, 0.95 * 15 / 16)],
 )
-def test_decay_constant_to_pauli_error(decay_constant, num_qubits, expected_output):
+def test_decay_constant_to_pauli_error(decay_constant, num_qubits, expected_output) -> None:
     val = decay_constant_to_pauli_error(decay_constant, num_qubits)
     assert val == expected_output
 
@@ -48,7 +50,7 @@ def test_decay_constant_to_pauli_error(decay_constant, num_qubits, expected_outp
     'pauli_error,num_qubits,expected_output',
     [(0.01, 1, 1 - (0.01 / (3 / 4))), (0.05, 2, 1 - (0.05 / (15 / 16)))],
 )
-def test_pauli_error_to_decay_constant(pauli_error, num_qubits, expected_output):
+def test_pauli_error_to_decay_constant(pauli_error, num_qubits, expected_output) -> None:
     val = pauli_error_to_decay_constant(pauli_error, num_qubits)
     assert val == expected_output
 
@@ -57,7 +59,7 @@ def test_pauli_error_to_decay_constant(pauli_error, num_qubits, expected_output)
     'xeb_fidelity,num_qubits,expected_output',
     [(0.01, 1, 1 - 0.99 / (1 / 2)), (0.05, 2, 1 - 0.95 / (3 / 4))],
 )
-def test_xeb_fidelity_to_decay_constant(xeb_fidelity, num_qubits, expected_output):
+def test_xeb_fidelity_to_decay_constant(xeb_fidelity, num_qubits, expected_output) -> None:
     val = xeb_fidelity_to_decay_constant(xeb_fidelity, num_qubits)
     assert val == expected_output
 
@@ -69,7 +71,7 @@ def test_xeb_fidelity_to_decay_constant(xeb_fidelity, num_qubits, expected_outpu
         (4000, 1e4, (1 - np.exp(-4000 / 2e4)) / 2 + (1 - np.exp(-4000 / 1e4)) / 4),
     ],
 )
-def test_pauli_error_from_t1(t, t1_ns, expected_output):
+def test_pauli_error_from_t1(t, t1_ns, expected_output) -> None:
     val = pauli_error_from_t1(t, t1_ns)
     assert val == expected_output
 
@@ -77,7 +79,7 @@ def test_pauli_error_from_t1(t, t1_ns, expected_output):
 @pytest.mark.parametrize(
     'decay_constant,num_qubits,expected_output', [(0.01, 1, 0.99 * 1 / 2), (0.05, 2, 0.95 * 3 / 4)]
 )
-def test_average_error(decay_constant, num_qubits, expected_output):
+def test_average_error(decay_constant, num_qubits, expected_output) -> None:
     val = average_error(decay_constant, num_qubits)
     assert val == expected_output
 
@@ -85,7 +87,7 @@ def test_average_error(decay_constant, num_qubits, expected_output):
 @pytest.mark.parametrize(
     'T1_ns,Tphi_ns,gate_time_ns', [(1e4, 2e4, 25), (1e5, 2e3, 25), (1e4, 2e4, 4000)]
 )
-def test_decoherence_pauli_error(T1_ns, Tphi_ns, gate_time_ns):
+def test_decoherence_pauli_error(T1_ns, Tphi_ns, gate_time_ns) -> None:
     val = decoherence_pauli_error(T1_ns, Tphi_ns, gate_time_ns)
     # Expected value is of the form:
     #