cirq-core 1.7.0.dev20250807224154__py3-none-any.whl → 1.7.0.dev20250812021254__py3-none-any.whl

cirq/experiments/benchmarking/parallel_xeb_test.py

@@ -37,8 +37,8 @@ _PAIRS = ((cirq.q(0, 0), cirq.q(0, 1)), (cirq.q(0, 2), cirq.q(0, 3)), (cirq.q(0,
 
 class TestXEBWideCircuitInfo:
 
-    def test_from_circuit(self):
-        permutation = [1, 2, 0]
+    def test_from_circuit(self) -> None:
+        permutation = np.array([1, 2, 0])
         target = cirq.CircuitOperation(cirq.FrozenCircuit(cirq.CNOT(*_QUBITS)))
         wide_circuit = xeb.XEBWideCircuitInfo.from_narrow_circuits(
             _CIRCUIT_TEMPLATES, permutation=permutation, pairs=_PAIRS, target=target
@@ -65,7 +65,7 @@ class TestXEBWideCircuitInfo:
             narrow_template_indices=permutation,
         )
 
-    def test_sliced_circuit(self):
+    def test_sliced_circuit(self) -> None:
         wid_circuit = xeb.XEBWideCircuitInfo(
             wide_circuit=cirq.Circuit.from_moments(
                 [
@@ -114,10 +114,14 @@ class TestXEBWideCircuitInfo:
         assert wid_circuit.sliced_circuits([1]) == [sliced_circuit]
 
 
-def test_create_combination_circuits():
+def test_create_combination_circuits() -> None:
     wide_circuits_info = xeb.create_combination_circuits(
         _CIRCUIT_TEMPLATES,
-        [rqcg.CircuitLibraryCombination(layer=None, combinations=[[1, 2, 0]], pairs=_PAIRS)],
+        [
+            rqcg.CircuitLibraryCombination(
+                layer=None, combinations=np.array([[1, 2, 0]]), pairs=_PAIRS
+            )
+        ],
         target=cirq.CNOT(*_QUBITS),
     )
 
@@ -142,10 +146,14 @@ def test_create_combination_circuits():
     ]
 
 
-def test_create_combination_circuits_with_target_dict():
+def test_create_combination_circuits_with_target_dict() -> None:
     wide_circuits_info = xeb.create_combination_circuits(
         _CIRCUIT_TEMPLATES,
-        [rqcg.CircuitLibraryCombination(layer=None, combinations=[[1, 2, 0]], pairs=_PAIRS)],
+        [
+            rqcg.CircuitLibraryCombination(
+                layer=None, combinations=np.array([[1, 2, 0]]), pairs=_PAIRS
+            )
+        ],
         target={_PAIRS[0]: cirq.CNOT(*_QUBITS), _PAIRS[1]: cirq.CZ(*_QUBITS)},
     )
 
@@ -164,7 +172,7 @@ def test_create_combination_circuits_with_target_dict():
     ]
 
 
-def test_simulate_circuit():
+def test_simulate_circuit() -> None:
     sim = cirq.Simulator(seed=0)
     circuit = cirq.Circuit.from_moments(
         cirq.X.on_each(_QUBITS),
@@ -180,7 +188,7 @@ def test_simulate_circuit():
     np.testing.assert_allclose(result, [[0, 1, 0, 0], [1, 0, 0, 0]])  # |01>  # |00>
 
 
-def test_simulate_circuit_library():
+def test_simulate_circuit_library() -> None:
     circuit_templates = [
         cirq.Circuit.from_moments(
             cirq.X.on_each(_QUBITS),
@@ -199,7 +207,7 @@ def test_simulate_circuit_library():
     np.testing.assert_allclose(result, [[[0, 1, 0, 0], [1, 0, 0, 0]]])  # |01>  # |00>
 
 
-def test_simulate_circuit_library_with_target_dict():
+def test_simulate_circuit_library_with_target_dict() -> None:
     circuit_templates = [
         cirq.Circuit.from_moments(
             [cirq.H(_QUBITS[0]), cirq.X(_QUBITS[1])],
@@ -219,13 +227,15 @@ def test_simulate_circuit_library_with_target_dict():
     )
 
     # First pair result.
-    np.testing.assert_allclose(result[_PAIRS[0]], [[[0.25, 0.25, 0.25, 0.25], [0, 1, 0, 0]]])
+    np.testing.assert_allclose(
+        result[_PAIRS[0]], [[[0.25, 0.25, 0.25, 0.25], [0.0, 1.0, 0.0, 0.0]]]
+    )
 
     # Second pair result.
     np.testing.assert_allclose(result[_PAIRS[1]], [[[0, 0, 1, 0], [1, 0, 0, 0]]])  # |10>  # |00>
 
 
-def test_sample_all_circuits():
+def test_sample_all_circuits() -> None:
     wide_circuits = [
         cirq.Circuit.from_moments(
             [cirq.Y.on_each(*_PAIRS[0]), cirq.Z.on_each(*_PAIRS[1]), cirq.X.on_each(*_PAIRS[2])],
@@ -252,7 +262,7 @@ def test_sample_all_circuits():
     )  # |01>
 
 
-def test_estimate_fidelities():
+def test_estimate_fidelities() -> None:
     sampling_result = [{str(_PAIRS[0]): np.array([0.15, 0.15, 0.35, 0.35])}]
 
     simulation_results = [[np.array([0.1, 0.2, 0.3, 0.4])]]
@@ -278,12 +288,14 @@ def test_estimate_fidelities():
         ],
     )
 
-    assert result == [
-        xeb.XEBFidelity(pair=_PAIRS[0], cycle_depth=1, fidelity=pytest.approx(0.785, abs=2e-4))
-    ]
+    assert len(result) == 1
+    xeb_fidelity = result[0]
+    assert xeb_fidelity.pair == _PAIRS[0]
+    assert xeb_fidelity.cycle_depth == 1
+    assert xeb_fidelity.fidelity == pytest.approx(0.785, abs=2e-4)
 
 
-def test_estimate_fidelities_with_dict_target():
+def test_estimate_fidelities_with_dict_target() -> None:
     sampling_result = [{str(_PAIRS[0]): np.array([0.15, 0.15, 0.35, 0.35])}]
 
     simulation_results = {_PAIRS[0]: [[np.array([0.1, 0.2, 0.3, 0.4])]]}
@@ -309,9 +321,11 @@ def test_estimate_fidelities_with_dict_target():
         ],
     )
 
-    assert result == [
-        xeb.XEBFidelity(pair=_PAIRS[0], cycle_depth=1, fidelity=pytest.approx(0.785, abs=2e-4))
-    ]
+    assert len(result) == 1
+    xeb_fidelity = result[0]
+    assert xeb_fidelity.pair == _PAIRS[0]
+    assert xeb_fidelity.cycle_depth == 1
+    assert xeb_fidelity.fidelity == pytest.approx(0.785, abs=2e-4)
 
 
 def _assert_fidelities_approx_equal(fids, expected: float, atol: float):
@@ -323,7 +337,7 @@ def _assert_fidelities_approx_equal(fids, expected: float, atol: float):
 
 @pytest.mark.parametrize('target', [cirq.CZ, cirq.Circuit(cirq.CZ(*_QUBITS)), cirq.CZ(*_QUBITS)])
 @pytest.mark.parametrize('pairs', [_PAIRS[:1], _PAIRS[:2]])
-def test_parallel_two_qubit_xeb(target, pairs):
+def test_parallel_two_qubit_xeb(target, pairs) -> None:
     sampler = cirq.DensityMatrixSimulator(noise=cirq.depolarize(0.03), seed=0)
     result = xeb.parallel_two_qubit_xeb(
         sampler=sampler,
@@ -349,17 +363,17 @@ class ExampleDevice(cirq.Device):
 
 
 class ExampleProcessor:
-    def get_device(self):
+    def get_device(self) -> ExampleDevice:
         return ExampleDevice()
 
 
 class DensityMatrixSimulatorWithProcessor(cirq.DensityMatrixSimulator):
     @property
-    def processor(self):
+    def processor(self) -> ExampleProcessor:
         return ExampleProcessor()
 
 
-def test_parallel_two_qubit_xeb_with_device():
+def test_parallel_two_qubit_xeb_with_device() -> None:
     target = cirq.CZ
     sampler = DensityMatrixSimulatorWithProcessor(noise=cirq.depolarize(0.03), seed=0)
     result = xeb.parallel_two_qubit_xeb(
@@ -380,7 +394,7 @@ def test_parallel_two_qubit_xeb_with_device():
     assert result.all_qubit_pairs == pairs
 
 
-def test_parallel_two_qubit_xeb_with_dict_target():
+def test_parallel_two_qubit_xeb_with_dict_target() -> None:
     target = {p: cirq.Circuit(cirq.CZ(*_QUBITS)) for p in _PAIRS[:2]}
     target[_PAIRS[2]] = cirq.CZ(*_QUBITS)
     sampler = cirq.DensityMatrixSimulator(noise=cirq.depolarize(0.03), seed=0)
@@ -395,7 +409,7 @@ def test_parallel_two_qubit_xeb_with_dict_target():
     assert result.all_qubit_pairs == _PAIRS
 
 
-def test_parallel_two_qubit_xeb_with_ideal_target():
+def test_parallel_two_qubit_xeb_with_ideal_target() -> None:
     target = {p: cirq.Circuit(cirq.CZ(*_QUBITS)) for p in _PAIRS[:2]}
     target[_PAIRS[2]] = cirq.CZ(*_QUBITS)
     sampler = cirq.DensityMatrixSimulator(noise=cirq.depolarize(0.03), seed=0)
@@ -417,7 +431,7 @@ def threading_pool() -> Iterator[futures.Executor]:
         yield pool
 
 
-def test_parallel_two_qubit_xeb_with_dict_target_and_pool(threading_pool):
+def test_parallel_two_qubit_xeb_with_dict_target_and_pool(threading_pool) -> None:
     target = {p: cirq.Circuit(cirq.CZ(*_QUBITS)) for p in _PAIRS}
     sampler = cirq.DensityMatrixSimulator(noise=cirq.depolarize(0.03), seed=0)
     result = xeb.parallel_two_qubit_xeb(
@@ -432,7 +446,7 @@ def test_parallel_two_qubit_xeb_with_dict_target_and_pool(threading_pool):
     assert result.all_qubit_pairs == _PAIRS
 
 
-def test_parallel_two_qubit_xeb_with_invalid_input_raises():
+def test_parallel_two_qubit_xeb_with_invalid_input_raises() -> None:
     with pytest.raises(AssertionError):
         _ = xeb.parallel_two_qubit_xeb(
             sampler=cirq.Simulator(seed=0), target={_PAIRS[0]: cirq.CZ}, pairs=_PAIRS

cirq/experiments/fidelity_estimation.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import Callable, Mapping, Sequence, TYPE_CHECKING
+from typing import Callable, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -141,7 +141,7 @@ def xeb_fidelity(
     circuit: cirq.Circuit,
     bitstrings: Sequence[int],
     qubit_order: QubitOrderOrList = QubitOrder.DEFAULT,
-    amplitudes: Mapping[int, complex] | None = None,
+    amplitudes: np.ndarray | None = None,
     estimator: Callable[[int, Sequence[float]], float] = linear_xeb_fidelity_from_probabilities,
 ) -> float:
     """Estimates XEB fidelity from one circuit using user-supplied estimator.
@@ -169,7 +169,7 @@ def xeb_fidelity(
             `cirq.final_state_vector`.
         qubit_order: Qubit order used to construct bitstrings enumerating
             qubits starting with the most significant qubit.
-        amplitudes: Optional mapping from bitstring to output amplitude.
+        amplitudes: Optional array of output amplitudes at bitstring indices.
             If provided, simulation is skipped. Useful for large circuits
             when an offline simulation had already been performed.
         estimator: Fidelity estimator to use, see above. Defaults to the
@@ -206,7 +206,7 @@ def linear_xeb_fidelity(
     circuit: cirq.Circuit,
     bitstrings: Sequence[int],
     qubit_order: QubitOrderOrList = QubitOrder.DEFAULT,
-    amplitudes: Mapping[int, complex] | None = None,
+    amplitudes: np.ndarray | None = None,
 ) -> float:
     """Estimates XEB fidelity from one circuit using linear estimator."""
     return xeb_fidelity(
@@ -222,7 +222,7 @@ def log_xeb_fidelity(
     circuit: cirq.Circuit,
     bitstrings: Sequence[int],
     qubit_order: QubitOrderOrList = QubitOrder.DEFAULT,
-    amplitudes: Mapping[int, complex] | None = None,
+    amplitudes: np.ndarray | None = None,
 ) -> float:
     """Estimates XEB fidelity from one circuit using logarithmic estimator."""
     return xeb_fidelity(

cirq/experiments/fidelity_estimation_test.py

@@ -25,7 +25,7 @@ import cirq
 
 def sample_noisy_bitstrings(
     circuit: cirq.Circuit, qubit_order: Sequence[cirq.Qid], depolarization: float, repetitions: int
-) -> np.ndarray:
+) -> Sequence[int]:
     assert 0 <= depolarization <= 1
     dim = np.prod(circuit.qid_shape(), dtype=np.int64)
     n_incoherent = int(depolarization * repetitions)
@@ -34,7 +34,7 @@ def sample_noisy_bitstrings(
     circuit_with_measurements = cirq.Circuit(circuit, cirq.measure(*qubit_order, key='m'))
     r = cirq.sample(circuit_with_measurements, repetitions=n_coherent)
     coherent_samples = r.data['m'].to_numpy()
-    return np.concatenate((coherent_samples, incoherent_samples))
+    return np.concatenate((coherent_samples, incoherent_samples)).tolist()
 
 
 def make_random_quantum_circuit(qubits: Sequence[cirq.Qid], depth: int) -> cirq.Circuit:
@@ -69,7 +69,7 @@ def make_random_quantum_circuit(qubits: Sequence[cirq.Qid], depth: int) -> cirq.
         ),
     ),
 )
-def test_xeb_fidelity(depolarization, estimator):
+def test_xeb_fidelity(depolarization, estimator) -> None:
     prng_state = np.random.get_state()
     np.random.seed(0)
 
@@ -95,7 +95,7 @@ def test_xeb_fidelity(depolarization, estimator):
     np.random.set_state(prng_state)
 
 
-def test_linear_and_log_xeb_fidelity():
+def test_linear_and_log_xeb_fidelity() -> None:
     prng_state = np.random.get_state()
     np.random.seed(0)
 
@@ -122,7 +122,7 @@ def test_linear_and_log_xeb_fidelity():
     np.random.set_state(prng_state)
 
 
-def test_xeb_fidelity_invalid_qubits():
+def test_xeb_fidelity_invalid_qubits() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0, q1))
     bitstrings = sample_noisy_bitstrings(circuit, (q0, q1, q2), 0.9, 10)
@@ -130,7 +130,7 @@ def test_xeb_fidelity_invalid_qubits():
         cirq.xeb_fidelity(circuit, bitstrings, (q0, q2))
 
 
-def test_xeb_fidelity_invalid_bitstrings():
+def test_xeb_fidelity_invalid_bitstrings() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0, q1))
     bitstrings = [0, 1, 2, 3, 4]
@@ -138,7 +138,7 @@ def test_xeb_fidelity_invalid_bitstrings():
         cirq.xeb_fidelity(circuit, bitstrings, (q0, q1))
 
 
-def test_xeb_fidelity_tuple_input():
+def test_xeb_fidelity_tuple_input() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0, q1))
     bitstrings = [0, 1, 2]

cirq/experiments/purity_estimation.py

@@ -20,7 +20,7 @@ import numpy as np
 
 
 def purity_from_probabilities(
-    hilbert_space_dimension: int, probabilities: Sequence[float]
+    hilbert_space_dimension: int, probabilities: np.ndarray | Sequence[float]
 ) -> float:
     """Purity estimator from speckle purity benchmarking.
 

cirq/experiments/purity_estimation_test.py

@@ -19,7 +19,7 @@ import numpy as np
 from cirq.experiments import purity_from_probabilities
 
 
-def test_purity_from_probabilities():
+def test_purity_from_probabilities() -> None:
     probabilities = np.random.uniform(0, 1, size=4)
     probabilities /= np.sum(probabilities)
     purity = purity_from_probabilities(4, probabilities)

cirq/experiments/qubit_characterizations_test.py

@@ -33,7 +33,7 @@ from cirq.experiments import (
 )
 
 
-def test_single_qubit_cliffords():
+def test_single_qubit_cliffords() -> None:
     I = np.eye(2)
     X = np.array([[0, 1], [1, 0]])
     Y = np.array([[0, -1j], [1j, 0]])
@@ -108,7 +108,7 @@ def test_single_qubit_cliffords():
 
 
 @mock.patch.dict(os.environ, clear='CIRQ_TESTING')
-def test_single_qubit_randomized_benchmarking():
+def test_single_qubit_randomized_benchmarking() -> None:
     # Check that the ground state population at the end of the Clifford
     # sequences is always unity.
     simulator = sim.Simulator()
@@ -121,7 +121,7 @@ def test_single_qubit_randomized_benchmarking():
 
 
 @mock.patch.dict(os.environ, clear='CIRQ_TESTING')
-def test_parallel_single_qubit_parallel_single_qubit_randomized_benchmarking():
+def test_parallel_single_qubit_parallel_single_qubit_randomized_benchmarking() -> None:
     # Check that the ground state population at the end of the Clifford
     # sequences is always unity.
     simulator = sim.Simulator()
@@ -140,7 +140,7 @@ def test_parallel_single_qubit_parallel_single_qubit_randomized_benchmarking():
     _ = results.plot_integrated_histogram()
 
 
-def test_two_qubit_randomized_benchmarking():
+def test_two_qubit_randomized_benchmarking() -> None:
     # Check that the ground state population at the end of the Clifford
     # sequences is always unity.
     simulator = sim.Simulator()
@@ -154,7 +154,7 @@ def test_two_qubit_randomized_benchmarking():
     assert np.isclose(np.mean(g_pops), 1.0)
 
 
-def test_single_qubit_state_tomography():
+def test_single_qubit_state_tomography() -> None:
     # Check that the density matrices of the output states of X/2, Y/2 and
     # H + Y gates closely match the ideal cases.
     # Checks that unique tomography keys are generated
@@ -187,7 +187,7 @@ def test_single_qubit_state_tomography():
     np.testing.assert_almost_equal(act_rho_5, tar_rho_5, decimal=1)
 
 
-def test_two_qubit_state_tomography():
+def test_two_qubit_state_tomography() -> None:
     # Check that the density matrices of the four Bell states closely match
     # the ideal cases. In addition, check that the output states of
     # single-qubit rotations (H, H), (X/2, Y/2), (Y/2, X/2) have the correct
@@ -231,14 +231,14 @@ def test_two_qubit_state_tomography():
 
 
 @pytest.mark.usefixtures('closefigures')
-def test_tomography_plot_raises_for_incorrect_number_of_axes():
+def test_tomography_plot_raises_for_incorrect_number_of_axes() -> None:
     simulator = sim.Simulator()
     qubit = GridQubit(0, 0)
     circuit = circuits.Circuit(ops.X(qubit) ** 0.5)
     result = single_qubit_state_tomography(simulator, qubit, circuit, 1000)
     with pytest.raises(TypeError):  # ax is not a list[plt.Axes]
         ax = plt.subplot()
-        result.plot(ax)
+        result.plot(ax)  # type: ignore[arg-type]
     with pytest.raises(ValueError):
         _, axes = plt.subplots(1, 3)
         result.plot(axes)
@@ -247,7 +247,7 @@ def test_tomography_plot_raises_for_incorrect_number_of_axes():
 @pytest.mark.parametrize('num_cliffords', range(5, 10))
 @pytest.mark.parametrize('use_xy_basis', [False, True])
 @pytest.mark.parametrize('strict_basis', [False, True])
-def test_single_qubit_cliffords_gateset(num_cliffords, use_xy_basis, strict_basis):
+def test_single_qubit_cliffords_gateset(num_cliffords, use_xy_basis, strict_basis) -> None:
     qubits = [GridQubit(0, i) for i in range(4)]
     c1_in_xy = cirq.experiments.qubit_characterizations.RBParameters(
         use_xy_basis=use_xy_basis, strict_basis=strict_basis
@@ -260,7 +260,7 @@ def test_single_qubit_cliffords_gateset(num_cliffords, use_xy_basis, strict_basi
         qubits, num_cliffords, c1_in_xy
     )
     device = cirq.testing.ValidatingTestDevice(
-        qubits=qubits, allowed_gates=(cirq.ops.PhasedXZGate, cirq.MeasurementGate)
+        qubits=set(qubits), allowed_gates=(cirq.ops.PhasedXZGate, cirq.MeasurementGate)
     )
     device.validate_circuit(c)
 

cirq/experiments/random_quantum_circuit_generation.py

@@ -297,7 +297,7 @@ class CircuitLibraryCombination:
 
     layer: Any | None
     combinations: np.ndarray
-    pairs: list[QidPairT]
+    pairs: Sequence[QidPairT]
 
 
 def _get_random_combinations(

cirq/experiments/random_quantum_circuit_generation_test.py

@@ -38,7 +38,7 @@ from cirq.experiments.random_quantum_circuit_generation import (
 SINGLE_QUBIT_LAYER = dict[cirq.GridQubit, cirq.Gate | None]
 
 
-def test_random_rotation_between_two_qubit_circuit():
+def test_random_rotation_between_two_qubit_circuit() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     circuit = random_rotations_between_two_qubit_circuit(q0, q1, 4, seed=52)
     assert len(circuit) == 4 * 2 + 1
@@ -75,7 +75,7 @@ X^0.5         PhX(0.25)^0.5
     )
 
 
-def test_generate_library_of_2q_circuits():
+def test_generate_library_of_2q_circuits() -> None:
     circuits = generate_library_of_2q_circuits(
         n_library_circuits=5, two_qubit_gate=cirq.CNOT, max_cycle_depth=13, random_state=9
     )
@@ -89,7 +89,7 @@ def test_generate_library_of_2q_circuits():
             assert m2.operations[0].gate == cirq.CNOT
 
 
-def test_generate_library_of_2q_circuits_custom_qubits():
+def test_generate_library_of_2q_circuits_custom_qubits() -> None:
     circuits = generate_library_of_2q_circuits(
         n_library_circuits=5,
         two_qubit_gate=cirq.ISWAP**0.5,
@@ -117,7 +117,7 @@ def _gridqubits_to_graph_device(qubits: Iterable[cirq.GridQubit]):
     )
 
 
-def test_get_random_combinations_for_device():
+def test_get_random_combinations_for_device() -> None:
     graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(3, 3))
     n_combinations = 4
     combinations = get_random_combinations_for_device(
@@ -136,7 +136,7 @@ def test_get_random_combinations_for_device():
         assert cirq.experiments.HALF_GRID_STAGGERED_PATTERN[i] == comb.layer
 
 
-def test_get_random_combinations_for_small_device():
+def test_get_random_combinations_for_small_device() -> None:
     graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(3, 1))
     n_combinations = 4
     combinations = get_random_combinations_for_device(
@@ -145,7 +145,8 @@ def test_get_random_combinations_for_small_device():
     assert len(combinations) == 2  # 3x1 device only fits two layers
 
 
-def test_get_random_combinations_for_pairs():
+def test_get_random_combinations_for_pairs() -> None:
+    all_pairs: list[list[tuple[cirq.Qid, cirq.Qid]]]
     all_pairs = [
         [(cirq.LineQubit(0), cirq.LineQubit(1)), (cirq.LineQubit(2), cirq.LineQubit(3))],
         [(cirq.LineQubit(1), cirq.LineQubit(2))],
@@ -167,7 +168,11 @@ def test_get_random_combinations_for_pairs():
         assert comb.pairs == all_pairs[i]
 
 
-def test_get_random_combinations_for_layer_circuit():
+def test_get_random_combinations_for_layer_circuit() -> None:
+    q0: cirq.Qid
+    q1: cirq.Qid
+    q2: cirq.Qid
+    q3: cirq.Qid
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     circuit = cirq.Circuit(cirq.CNOT(q0, q1), cirq.CNOT(q2, q3), cirq.CNOT(q1, q2))
     combinations = get_random_combinations_for_layer_circuit(
@@ -186,7 +191,7 @@ def test_get_random_combinations_for_layer_circuit():
         assert comb.layer == circuit.moments[i]
 
 
-def test_get_random_combinations_for_bad_layer_circuit():
+def test_get_random_combinations_for_bad_layer_circuit() -> None:
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     circuit = cirq.Circuit(
         cirq.H.on_each(q0, q1, q2, q3), cirq.CNOT(q0, q1), cirq.CNOT(q2, q3), cirq.CNOT(q1, q2)
@@ -198,7 +203,7 @@ def test_get_random_combinations_for_bad_layer_circuit():
         )
 
 
-def test_get_grid_interaction_layer_circuit():
+def test_get_grid_interaction_layer_circuit() -> None:
     graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(3, 3))
     layer_circuit = get_grid_interaction_layer_circuit(graph)
 
@@ -225,7 +230,7 @@ def test_get_grid_interaction_layer_circuit():
     assert layer_circuit == should_be
 
 
-def test_random_combinations_layer_circuit_vs_device():
+def test_random_combinations_layer_circuit_vs_device() -> None:
     # Random combinations from layer circuit is the same as getting it directly from graph
     graph = _gridqubits_to_graph_device(cirq.GridQubit.rect(3, 3))
     layer_circuit = get_grid_interaction_layer_circuit(graph)
@@ -373,7 +378,7 @@ def test_random_rotations_between_grid_interaction_layers(
     expected_circuit_length: int,
     single_qubit_layers_slice: slice,
     two_qubit_layers_slice: slice,
-):
+) -> None:
     qubits = set(qubits)
     circuit = random_rotations_between_grid_interaction_layers_circuit(
         qubits,
@@ -396,7 +401,7 @@ def test_random_rotations_between_grid_interaction_layers(
     )
 
 
-def test_grid_interaction_layer_repr():
+def test_grid_interaction_layer_repr() -> None:
     layer = GridInteractionLayer(col_offset=0, vertical=True, stagger=False)
     assert repr(layer) == (
         'cirq.experiments.GridInteractionLayer(col_offset=0, vertical=True, stagger=False)'
@@ -462,7 +467,7 @@ def _coupled_qubit_pairs(
     return pairs
 
 
-def test_generate_library_of_2q_circuits_with_tags():
+def test_generate_library_of_2q_circuits_with_tags() -> None:
     circuits = generate_library_of_2q_circuits(
         n_library_circuits=5,
         two_qubit_gate=cirq.FSimGate(3, 4),

cirq/experiments/readout_confusion_matrix_test.py

@@ -14,6 +14,8 @@
 
 from __future__ import annotations
 
+from typing import Sequence
+
 import numpy as np
 import pytest
 
@@ -49,7 +51,7 @@ def add_readout_error(
     return noisy_measurements.astype(int)
 
 
-def get_expected_cm(num_qubits: int, p0: float, p1: float):
+def get_expected_cm(num_qubits: int, p0: float, p1: float) -> np.ndarray:
     expected_cm = np.zeros((2**num_qubits,) * 2)
     for i in range(2**num_qubits):
         for j in range(2**num_qubits):
@@ -66,7 +68,7 @@ def get_expected_cm(num_qubits: int, p0: float, p1: float):
 
 
 @pytest.mark.parametrize('p0, p1', [(0, 0), (0.2, 0.4), (0.5, 0.5), (0.6, 0.3), (1.0, 1.0)])
-def test_measure_confusion_matrix_with_noise(p0, p1):
+def test_measure_confusion_matrix_with_noise(p0, p1) -> None:
     sampler = NoisySingleQubitReadoutSampler(p0, p1, seed=1234)
     num_qubits = 4
     qubits = cirq.LineQubit.range(num_qubits)
@@ -113,8 +115,8 @@ def test_measure_confusion_matrix_with_noise(p0, p1):
     assert l2norm(corrected_result) <= l2norm(sampled_result)
 
 
-def test_from_measurement():
-    qubits = cirq.LineQubit.range(3)
+def test_from_measurement() -> None:
+    qubits: Sequence[cirq.Qid] = cirq.LineQubit.range(3)
     confuse_02 = np.array([[0, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 0]])
     confuse_1 = np.array([[0, 1], [1, 0]])
     op = cirq.measure(
@@ -123,6 +125,7 @@ def test_from_measurement():
         invert_mask=(True, False),
         confusion_map={(0, 2): confuse_02, (1,): confuse_1},
     )
+    assert isinstance(op.gate, cirq.MeasurementGate)
     tcm = cirq.TensoredConfusionMatrices.from_measurement(op.gate, op.qubits)
     expected_tcm = cirq.TensoredConfusionMatrices(
         [confuse_02, confuse_1], ((qubits[0], qubits[2]), (qubits[1],)), repetitions=0, timestamp=0
@@ -130,11 +133,12 @@ def test_from_measurement():
     assert tcm == expected_tcm
 
     no_cm_op = cirq.measure(*qubits, key='a')
+    assert isinstance(no_cm_op.gate, cirq.MeasurementGate)
     with pytest.raises(ValueError, match="Measurement has no confusion matrices"):
         _ = cirq.TensoredConfusionMatrices.from_measurement(no_cm_op.gate, no_cm_op.qubits)
 
 
-def test_readout_confusion_matrix_raises():
+def test_readout_confusion_matrix_raises() -> None:
     num_qubits = 2
     confusion_matrix = get_expected_cm(num_qubits, 0.1, 0.2)
     qubits = cirq.LineQubit.range(4)
@@ -174,7 +178,7 @@ def test_readout_confusion_matrix_raises():
         _ = readout_cm.apply(np.asarray([1 / 16] * 16), method='l1norm')
 
 
-def test_readout_confusion_matrix_repr_and_equality():
+def test_readout_confusion_matrix_repr_and_equality() -> None:
     mat1 = cirq.testing.random_orthogonal(4, random_state=1234)
     mat2 = cirq.testing.random_orthogonal(2, random_state=1234)
     q = cirq.LineQubit.range(3)
@@ -245,8 +249,8 @@ def _add_noise_and_mitigate_ghz(
     return (*tcm.readout_mitigation_pauli_uncorrelated(qubits, noisy_measurements), z, dz)
 
 
-def test_uncorrelated_readout_mitigation_pauli():
-    n_all = np.arange(2, 35)
+def test_uncorrelated_readout_mitigation_pauli() -> None:
+    n_all = list(range(2, 35))
     z_all_mit = []
     dz_all_mit = []
     z_all_raw = []