cirq-core 1.7.0.dev20250818230756__py3-none-any.whl → 1.7.0.dev20250820205919__py3-none-any.whl

cirq/ops/matrix_gates_test.py

@@ -28,7 +28,7 @@ QFT2 = np.array([[1, 1, 1, 1], [1, 1j, -1, -1j], [1, -1, 1, -1], [1, -1j, -1, 1j
 PLUS_ONE = np.array([[0, 0, 1], [1, 0, 0], [0, 1, 0]])
 
 
-def test_single_qubit_init():
+def test_single_qubit_init() -> None:
     m = np.array([[1, 1j], [1j, 1]]) * np.sqrt(0.5)
     x2 = cirq.MatrixGate(m)
     assert cirq.has_unitary(x2)
@@ -50,7 +50,7 @@ def test_single_qubit_init():
         cirq.MatrixGate(np.ones((2, 2, 2)))
 
 
-def test_single_qubit_eq():
+def test_single_qubit_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(lambda: cirq.MatrixGate(np.eye(2)))
     eq.make_equality_group(lambda: cirq.MatrixGate(np.array([[0, 1], [1, 0]])))
@@ -59,14 +59,14 @@ def test_single_qubit_eq():
     eq.add_equality_group(cirq.MatrixGate(PLUS_ONE, qid_shape=(3,)))
 
 
-def test_single_qubit_trace_distance_bound():
+def test_single_qubit_trace_distance_bound() -> None:
     x = cirq.MatrixGate(np.array([[0, 1], [1, 0]]))
     x2 = cirq.MatrixGate(np.array([[1, 1j], [1j, 1]]) * np.sqrt(0.5))
     assert cirq.trace_distance_bound(x) >= 1
     assert cirq.trace_distance_bound(x2) >= 0.5
 
 
-def test_single_qubit_approx_eq():
+def test_single_qubit_approx_eq() -> None:
     x = cirq.MatrixGate(np.array([[0, 1], [1, 0]]))
     i = cirq.MatrixGate(np.array([[1, 0], [0, 1]]))
     i_ish = cirq.MatrixGate(np.array([[1, 0.000000000000001], [0, 1]]))
@@ -76,7 +76,7 @@ def test_single_qubit_approx_eq():
     assert not cirq.approx_eq(i, '', atol=1e-9)
 
 
-def test_single_qubit_extrapolate():
+def test_single_qubit_extrapolate() -> None:
     i = cirq.MatrixGate(np.eye(2))
     x = cirq.MatrixGate(np.array([[0, 1], [1, 0]]))
     x2 = cirq.MatrixGate(np.array([[1, 1j], [1j, 1]]) * (1 - 1j) / 2)
@@ -97,20 +97,20 @@ def test_single_qubit_extrapolate():
         _ = x ** sympy.Symbol('a')
 
 
-def test_two_qubit_init():
+def test_two_qubit_init() -> None:
     x2 = cirq.MatrixGate(QFT2)
     assert cirq.has_unitary(x2)
     assert np.all(cirq.unitary(x2) == QFT2)
 
 
-def test_two_qubit_eq():
+def test_two_qubit_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(lambda: cirq.MatrixGate(np.eye(4)))
     eq.make_equality_group(lambda: cirq.MatrixGate(QFT2))
     eq.make_equality_group(lambda: cirq.MatrixGate(HH))
 
 
-def test_two_qubit_approx_eq():
+def test_two_qubit_approx_eq() -> None:
     f = cirq.MatrixGate(QFT2)
     perturb = np.zeros(shape=QFT2.shape, dtype=np.float64)
     perturb[1, 2] = 1e-8
@@ -123,7 +123,7 @@ def test_two_qubit_approx_eq():
     assert not cirq.approx_eq(f, cirq.MatrixGate(HH), atol=1e-9)
 
 
-def test_two_qubit_extrapolate():
+def test_two_qubit_extrapolate() -> None:
     cz2 = cirq.MatrixGate(np.diag([1, 1, 1, 1j]))
     cz4 = cirq.MatrixGate(np.diag([1, 1, 1, (1 + 1j) * np.sqrt(0.5)]))
     i = cirq.MatrixGate(np.eye(4))
@@ -135,7 +135,7 @@ def test_two_qubit_extrapolate():
         _ = cz2 ** sympy.Symbol('a')
 
 
-def test_single_qubit_diagram():
+def test_single_qubit_diagram() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     m = np.array([[1, 1j], [1j, 1]]) * np.sqrt(0.5)
@@ -169,11 +169,11 @@ a[          ]+  b
     )
 
 
-def test_two_qubit_diagram():
+def test_two_qubit_diagram() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
-    c = cirq.Circuit(
+    circuit = cirq.Circuit(
         cirq.MatrixGate(cirq.unitary(cirq.CZ)).on(a, b),
         cirq.MatrixGate(cirq.unitary(cirq.CZ)).on(c, a),
     )
@@ -195,7 +195,7 @@ c: ────[──────────]+────│[0-9\.+\-j ]+│
        [          ]+    │[0-9\.+\-j ]+│
        [          ]+    └[          ]+┘
     """.strip(),
-        c.to_text_diagram().strip(),
+        circuit.to_text_diagram().strip(),
     )
 
     assert re.match(
@@ -217,11 +217,11 @@ a[          ]+  b  c
 │[          ]+  │  └[          ]+┘
 │[          ]+  │  │
     """.strip(),
-        c.to_text_diagram(transpose=True).strip(),
+        circuit.to_text_diagram(transpose=True).strip(),
     )
 
 
-def test_named_single_qubit_diagram():
+def test_named_single_qubit_diagram() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     m = np.array([[1, 1j], [1j, 1]]) * np.sqrt(0.5)
@@ -245,11 +245,11 @@ Foo │
     assert expected_vertical == c.to_text_diagram(transpose=True).strip()
 
 
-def test_named_two_qubit_diagram():
+def test_named_two_qubit_diagram() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
-    c = cirq.Circuit(
+    circuit = cirq.Circuit(
         cirq.MatrixGate(cirq.unitary(cirq.CZ), name='Foo').on(a, b),
         cirq.MatrixGate(cirq.unitary(cirq.CZ), name='Bar').on(c, a),
     )
@@ -261,7 +261,7 @@ b: ───Foo[2]───┼────────
                │
 c: ────────────Bar[1]───
     """.strip()
-    assert expected_horizontal == c.to_text_diagram().strip()
+    assert expected_horizontal == circuit.to_text_diagram().strip()
 
     expected_vertical = """
 a      b      c
@@ -271,10 +271,10 @@ Foo[1]─Foo[2] │
 Bar[2]─┼──────Bar[1]
 │      │      │
     """.strip()
-    assert expected_vertical == c.to_text_diagram(transpose=True).strip()
+    assert expected_vertical == circuit.to_text_diagram(transpose=True).strip()
 
 
-def test_with_name():
+def test_with_name() -> None:
     gate = cirq.MatrixGate(cirq.unitary(cirq.Z**0.25))
     T = gate.with_name('T')
     S = (T**2).with_name('S')
@@ -284,13 +284,13 @@ def test_with_name():
     np.testing.assert_allclose(cirq.unitary(S), cirq.unitary(T**2))
 
 
-def test_str_executes():
+def test_str_executes() -> None:
     assert '1' in str(cirq.MatrixGate(np.eye(2)))
     assert '0' in str(cirq.MatrixGate(np.eye(4)))
 
 
 @pytest.mark.parametrize('n', [1, 2, 3, 4, 5])
-def test_implements_consistent_protocols(n):
+def test_implements_consistent_protocols(n) -> None:
     u = cirq.testing.random_unitary(2**n)
     g1 = cirq.MatrixGate(u)
     cirq.testing.assert_implements_consistent_protocols(g1, ignoring_global_phase=True)
@@ -304,12 +304,12 @@ def test_implements_consistent_protocols(n):
     cirq.testing.assert_decompose_ends_at_default_gateset(g2)
 
 
-def test_repr():
+def test_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.MatrixGate(cirq.testing.random_unitary(2)))
     cirq.testing.assert_equivalent_repr(cirq.MatrixGate(cirq.testing.random_unitary(4)))
 
 
-def test_matrix_gate_init_validation():
+def test_matrix_gate_init_validation() -> None:
     with pytest.raises(ValueError, match='square 2d numpy array'):
         _ = cirq.MatrixGate(np.ones(shape=(1, 1, 1)))
     with pytest.raises(ValueError, match='square 2d numpy array'):
@@ -322,7 +322,7 @@ def test_matrix_gate_init_validation():
         _ = cirq.MatrixGate(np.eye(3), qid_shape=(4,))
 
 
-def test_matrix_gate_eq():
+def test_matrix_gate_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.MatrixGate(np.eye(1)))
     eq.add_equality_group(cirq.MatrixGate(-np.eye(1)))
@@ -330,7 +330,7 @@ def test_matrix_gate_eq():
     eq.add_equality_group(cirq.MatrixGate(np.diag([1, 1, 1, 1, 1, -1]), qid_shape=(3, 2)))
 
 
-def test_matrix_gate_pow():
+def test_matrix_gate_pow() -> None:
     t = sympy.Symbol('t')
     assert cirq.pow(cirq.MatrixGate(1j * np.eye(1)), t, default=None) is None
     assert cirq.pow(cirq.MatrixGate(1j * np.eye(1)), 2) == cirq.MatrixGate(-np.eye(1))
@@ -339,7 +339,7 @@ def test_matrix_gate_pow():
     assert m**3 == cirq.MatrixGate(np.diag([1, -1j, -1]), qid_shape=(3,))
 
 
-def test_phase_by():
+def test_phase_by() -> None:
     # Single qubit case.
     x = cirq.MatrixGate(cirq.unitary(cirq.X))
     y = cirq.phase_by(x, 0.25, 0)
@@ -363,14 +363,14 @@ def test_phase_by():
         _ = cirq.phase_by(m, 0.25, 0)
 
 
-def test_protocols_and_repr():
+def test_protocols_and_repr() -> None:
     cirq.testing.assert_implements_consistent_protocols(cirq.MatrixGate(np.diag([1, 1j, 1, -1])))
     cirq.testing.assert_implements_consistent_protocols(
         cirq.MatrixGate(np.diag([1, 1j, -1]), qid_shape=(3,))
     )
 
 
-def test_matrixgate_unitary_tolerance():
+def test_matrixgate_unitary_tolerance() -> None:
     ## non-unitary matrix
     with pytest.raises(ValueError):
         _ = cirq.MatrixGate(np.array([[1, 0], [0, -0.6]]), unitary_check_atol=0.5)
@@ -393,7 +393,7 @@ def test_matrixgate_unitary_tolerance():
         _ = cirq.MatrixGate(np.array([[0.707, 0.707], [-0.707, 0.707]]), unitary_check_rtol=1e-10)
 
 
-def test_matrixgate_name_serialization():
+def test_matrixgate_name_serialization() -> None:
     # https://github.com/quantumlib/Cirq/issues/5999
 
     # Test name serialization
@@ -415,7 +415,7 @@ def test_matrixgate_name_serialization():
     assert gate_after_serialization3._name == ''
 
 
-def test_decompose_when_qubits_not_in_ascending_order():
+def test_decompose_when_qubits_not_in_ascending_order() -> None:
     # Previous code for preserving global phase would misorder qubits
     q0, q1 = cirq.LineQubit.range(2)
     circuit1 = cirq.Circuit()

cirq/ops/measure_util_test.py

@@ -20,7 +20,7 @@ import pytest
 import cirq
 
 
-def test_measure_qubits():
+def test_measure_qubits() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -48,6 +48,7 @@ def test_measure_qubits():
     assert cirq.measure(cirq.LineQid.for_qid_shape((1, 2, 3)), key='a') == cirq.MeasurementGate(
         num_qubits=3, key='a', qid_shape=(1, 2, 3)
     ).on(*cirq.LineQid.for_qid_shape((1, 2, 3)))
+    cmap: dict[tuple[int, ...], np.ndarray]
     cmap = {(0,): np.array([[0, 1], [1, 0]])}
     assert cirq.measure(a, confusion_map=cmap) == cirq.MeasurementGate(
         num_qubits=1, key='a', confusion_map=cmap
@@ -57,16 +58,16 @@ def test_measure_qubits():
         _ = cirq.measure(np.array([1, 0]))
 
     with pytest.raises(ValueError, match='Qid'):
-        _ = cirq.measure("bork")
+        _ = cirq.measure("bork")  # type: ignore[arg-type]
 
     with pytest.raises(ValueError, match='Qid'):
-        _ = cirq.measure([a, [b]])
+        _ = cirq.measure([a, [b]])  # type: ignore[list-item]
 
     with pytest.raises(ValueError, match='Qid'):
-        _ = cirq.measure([a], [b])
+        _ = cirq.measure([a], [b])  # type: ignore
 
 
-def test_measure_each():
+def test_measure_each() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -83,13 +84,13 @@ def test_measure_each():
         cirq.measure(b.with_dimension(3)),
     ]
 
-    assert cirq.measure_each(a, b, key_func=lambda e: e.name + '!') == [
+    assert cirq.measure_each(a, b, key_func=lambda e: e.name + '!') == [  # type: ignore[attr-defined]
         cirq.measure(a, key='a!'),
         cirq.measure(b, key='b!'),
     ]
 
 
-def test_measure_single_paulistring():
+def test_measure_single_paulistring() -> None:
     # Correct application
     q = cirq.LineQubit.range(3)
     ps = cirq.X(q[0]) * cirq.Y(q[1]) * cirq.Z(q[2])
@@ -109,14 +110,14 @@ def test_measure_single_paulistring():
 
     # Wrong type
     with pytest.raises(ValueError, match='should be an instance of cirq.PauliString'):
-        _ = cirq.measure_single_paulistring(q)
+        _ = cirq.measure_single_paulistring(q)  # type: ignore[arg-type]
 
     # Coefficient != +1 or -1
     with pytest.raises(ValueError, match='must have a coefficient'):
         _ = cirq.measure_single_paulistring(-2 * ps)
 
 
-def test_measure_paulistring_terms():
+def test_measure_paulistring_terms() -> None:
     # Correct application
     q = cirq.LineQubit.range(3)
     ps = cirq.X(q[0]) * cirq.Y(q[1]) * cirq.Z(q[2])
@@ -132,4 +133,4 @@ def test_measure_paulistring_terms():
 
     # Wrong type
     with pytest.raises(ValueError, match='should be an instance of cirq.PauliString'):
-        _ = cirq.measure_paulistring_terms(q)
+        _ = cirq.measure_paulistring_terms(q)  # type: ignore[arg-type]

cirq/ops/measurement_gate_test.py

@@ -26,14 +26,14 @@ import cirq
     'key',
     ['q0_1_0', cirq.MeasurementKey(name='q0_1_0'), cirq.MeasurementKey(path=('a', 'b'), name='c')],
 )
-def test_eval_repr(key):
+def test_eval_repr(key) -> None:
     # Basic safeguard against repr-inequality.
     op = cirq.GateOperation(gate=cirq.MeasurementGate(1, key), qubits=[cirq.GridQubit(0, 1)])
     cirq.testing.assert_equivalent_repr(op)
 
 
 @pytest.mark.parametrize('num_qubits', [1, 2, 4])
-def test_measure_init(num_qubits):
+def test_measure_init(num_qubits) -> None:
     assert cirq.MeasurementGate(num_qubits, 'a').num_qubits() == num_qubits
     assert cirq.MeasurementGate(num_qubits, key='a').key == 'a'
     assert cirq.MeasurementGate(num_qubits, key='a').mkey == cirq.MeasurementKey('a')
@@ -43,11 +43,12 @@ def test_measure_init(num_qubits):
     )
     assert cirq.MeasurementGate(num_qubits, 'a', invert_mask=(True,)).invert_mask == (True,)
     assert cirq.qid_shape(cirq.MeasurementGate(num_qubits, 'a')) == (2,) * num_qubits
+    cmap: dict[tuple[int, ...], np.ndarray]
     cmap = {(0,): np.array([[0, 1], [1, 0]])}
     assert cirq.MeasurementGate(num_qubits, 'a', confusion_map=cmap).confusion_map == cmap
 
 
-def test_measure_init_num_qubit_agnostic():
+def test_measure_init_num_qubit_agnostic() -> None:
     assert cirq.qid_shape(cirq.MeasurementGate(3, 'a', qid_shape=(1, 2, 3))) == (1, 2, 3)
     assert cirq.qid_shape(cirq.MeasurementGate(key='a', qid_shape=(1, 2, 3))) == (1, 2, 3)
     with pytest.raises(ValueError, match='len.* >'):
@@ -55,24 +56,24 @@ def test_measure_init_num_qubit_agnostic():
     with pytest.raises(ValueError, match='len.* !='):
         cirq.MeasurementGate(5, 'a', qid_shape=(1, 2))
     with pytest.raises(ValueError, match='valid string'):
-        cirq.MeasurementGate(2, qid_shape=(1, 2), key=None)
+        cirq.MeasurementGate(2, qid_shape=(1, 2), key=None)  # type: ignore[arg-type]
     with pytest.raises(ValueError, match='Confusion matrices have index out of bounds'):
         cirq.MeasurementGate(1, 'a', confusion_map={(1,): np.array([[0, 1], [1, 0]])})
     with pytest.raises(ValueError, match='Specify either'):
         cirq.MeasurementGate()
 
 
-def test_measurement_has_unitary_returns_false():
+def test_measurement_has_unitary_returns_false() -> None:
     gate = cirq.MeasurementGate(1, 'a')
     assert not cirq.has_unitary(gate)
 
 
 @pytest.mark.parametrize('num_qubits', [1, 2, 4])
-def test_has_stabilizer_effect(num_qubits):
+def test_has_stabilizer_effect(num_qubits) -> None:
     assert cirq.has_stabilizer_effect(cirq.MeasurementGate(num_qubits, 'a'))
 
 
-def test_measurement_eq():
+def test_measurement_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(
         lambda: cirq.MeasurementGate(1, 'a'),
@@ -93,7 +94,7 @@ def test_measurement_eq():
     eq.add_equality_group(cirq.MeasurementGate(3, 'a', qid_shape=(1, 2, 3)))
 
 
-def test_measurement_full_invert_mask():
+def test_measurement_full_invert_mask() -> None:
     assert cirq.MeasurementGate(1, 'a').full_invert_mask() == (False,)
     assert cirq.MeasurementGate(2, 'a', invert_mask=(False, True)).full_invert_mask() == (
         False,
@@ -112,7 +113,7 @@ def test_measurement_full_invert_mask():
         cirq.MeasurementGate(2, 'a', invert_mask=(True, False), qid_shape=(2, 3)),
     ],
 )
-def test_measurement_with_key(use_protocol, gate):
+def test_measurement_with_key(use_protocol, gate) -> None:
     if use_protocol:
         gate1 = cirq.with_measurement_key_mapping(gate, {'a': 'b'})
     else:
@@ -136,7 +137,7 @@ def test_measurement_with_key(use_protocol, gate):
         (3, (False, False), [0, 2], (True, False, True)),
     ],
 )
-def test_measurement_with_bits_flipped(num_qubits, mask, bits, flipped):
+def test_measurement_with_bits_flipped(num_qubits, mask, bits, flipped) -> None:
     gate = cirq.MeasurementGate(num_qubits, key='a', invert_mask=mask, qid_shape=(3,) * num_qubits)
 
     gate1 = gate.with_bits_flipped(*bits)
@@ -150,7 +151,7 @@ def test_measurement_with_bits_flipped(num_qubits, mask, bits, flipped):
     assert gate2.full_invert_mask() == gate.full_invert_mask()
 
 
-def test_qudit_measure_qasm():
+def test_qudit_measure_qasm() -> None:
     assert (
         cirq.qasm(
             cirq.measure(cirq.LineQid(0, 3), key='a'),
@@ -161,7 +162,7 @@ def test_qudit_measure_qasm():
     )
 
 
-def test_confused_measure_qasm():
+def test_confused_measure_qasm() -> None:
     q0 = cirq.LineQubit(0)
     assert (
         cirq.qasm(
@@ -173,7 +174,7 @@ def test_confused_measure_qasm():
     )
 
 
-def test_measurement_gate_diagram():
+def test_measurement_gate_diagram() -> None:
     # Shows key.
     assert cirq.circuit_diagram_info(
         cirq.MeasurementGate(1, key='test')
@@ -245,7 +246,7 @@ b: ───M───────────
     )
 
 
-def test_measurement_channel():
+def test_measurement_channel() -> None:
     np.testing.assert_allclose(
         cirq.kraus(cirq.MeasurementGate(1, 'a')),
         (np.array([[1, 0], [0, 0]]), np.array([[0, 0], [0, 1]])),
@@ -282,7 +283,7 @@ def test_measurement_channel():
     # yapf: enable
 
 
-def test_measurement_qubit_count_vs_mask_length():
+def test_measurement_qubit_count_vs_mask_length() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -296,7 +297,7 @@ def test_measurement_qubit_count_vs_mask_length():
         _ = cirq.MeasurementGate(num_qubits=3, key='a', invert_mask=(True, False, True)).on(a, b)
 
 
-def test_consistent_protocols():
+def test_consistent_protocols() -> None:
     for n in range(1, 5):
         gate = cirq.MeasurementGate(num_qubits=n, key='a')
         cirq.testing.assert_implements_consistent_protocols(gate)
@@ -305,7 +306,7 @@ def test_consistent_protocols():
         cirq.testing.assert_implements_consistent_protocols(gate)
 
 
-def test_op_repr():
+def test_op_repr() -> None:
     a, b = cirq.LineQubit.range(2)
     assert repr(cirq.measure(a)) == 'cirq.measure(cirq.LineQubit(0))'
     assert repr(cirq.measure(a, b)) == ('cirq.measure(cirq.LineQubit(0), cirq.LineQubit(1))')
@@ -330,7 +331,7 @@ def test_op_repr():
     )
 
 
-def test_repr():
+def test_repr() -> None:
     gate = cirq.MeasurementGate(
         3,
         'a',
@@ -345,7 +346,7 @@ def test_repr():
     )
 
 
-def test_act_on_state_vector():
+def test_act_on_state_vector() -> None:
     a, b = [cirq.LineQubit(3), cirq.LineQubit(1)]
     m = cirq.measure(
         a, b, key='out', invert_mask=(True,), confusion_map={(1,): np.array([[0, 1], [1, 0]])}
@@ -392,7 +393,7 @@ def test_act_on_state_vector():
     assert datastore.records[out] == [(0, 0), (0, 0)]
 
 
-def test_act_on_clifford_tableau():
+def test_act_on_clifford_tableau() -> None:
     a, b = [cirq.LineQubit(3), cirq.LineQubit(1)]
     m = cirq.measure(
         a, b, key='out', invert_mask=(True,), confusion_map={(1,): np.array([[0, 1], [1, 0]])}
@@ -432,7 +433,7 @@ def test_act_on_clifford_tableau():
     assert datastore.records[out] == [(0, 0), (0, 0)]
 
 
-def test_act_on_stabilizer_ch_form():
+def test_act_on_stabilizer_ch_form() -> None:
     a, b = [cirq.LineQubit(3), cirq.LineQubit(1)]
     m = cirq.measure(
         a, b, key='out', invert_mask=(True,), confusion_map={(1,): np.array([[0, 1], [1, 0]])}
@@ -466,7 +467,7 @@ def test_act_on_stabilizer_ch_form():
     assert datastore.records[out] == [(0, 0), (0, 0)]
 
 
-def test_act_on_qutrit():
+def test_act_on_qutrit() -> None:
     a, b = [cirq.LineQid(3, dimension=3), cirq.LineQid(1, dimension=3)]
     m = cirq.measure(
         a,

cirq/ops/pauli_gates.py

@@ -56,7 +56,7 @@ class Pauli(raw_types.Gate, metaclass=abc.ABCMeta):
         self._index = index
         self._name = name
 
-    def num_qubits(self):
+    def num_qubits(self) -> int:
         return 1
 
     def _commutes_(self, other: Any, *, atol: float = 1e-8) -> bool | NotImplementedType | None:

cirq/ops/pauli_measurement_gate_test.py

@@ -23,7 +23,7 @@ import cirq
     'key',
     ['q0_1_0', cirq.MeasurementKey(name='q0_1_0'), cirq.MeasurementKey(path=('a', 'b'), name='c')],
 )
-def test_eval_repr(key):
+def test_eval_repr(key) -> None:
     # Basic safeguard against repr-inequality.
     op = cirq.GateOperation(
         gate=cirq.PauliMeasurementGate([cirq.X, cirq.Y], key),
@@ -36,7 +36,7 @@ def test_eval_repr(key):
 
 @pytest.mark.parametrize('observable', [[cirq.X], [cirq.Y, cirq.Z], cirq.DensePauliString('XYZ')])
 @pytest.mark.parametrize('key', ['a', cirq.MeasurementKey('a')])
-def test_init(observable, key):
+def test_init(observable, key) -> None:
     g = cirq.PauliMeasurementGate(observable, key)
     assert g.num_qubits() == len(observable)
     assert g.key == 'a'
@@ -45,12 +45,12 @@ def test_init(observable, key):
     assert cirq.qid_shape(g) == (2,) * len(observable)
 
 
-def test_measurement_has_unitary_returns_false():
+def test_measurement_has_unitary_returns_false() -> None:
     gate = cirq.PauliMeasurementGate([cirq.X], 'a')
     assert not cirq.has_unitary(gate)
 
 
-def test_measurement_eq():
+def test_measurement_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(
         lambda: cirq.PauliMeasurementGate([cirq.X, cirq.Y], 'a'),
@@ -76,7 +76,7 @@ def test_measurement_eq():
         cirq.PauliMeasurementGate([cirq.X, cirq.Y, cirq.Z], 'a'),
     ],
 )
-def test_measurement_with_key(protocol, args, key, gate):
+def test_measurement_with_key(protocol, args, key, gate) -> None:
     if protocol:
         gate_with_key = protocol(gate, args)
     else:
@@ -92,7 +92,7 @@ def test_measurement_with_key(protocol, args, key, gate):
     assert same_gate == gate
 
 
-def test_measurement_gate_diagram():
+def test_measurement_gate_diagram() -> None:
     # Shows observable & key.
     assert cirq.circuit_diagram_info(
         cirq.PauliMeasurementGate([cirq.X], key='test')
@@ -129,14 +129,14 @@ b: ───M(Y)───────────
     'key',
     ['q0_1_0', cirq.MeasurementKey(name='q0_1_0'), cirq.MeasurementKey(path=('a', 'b'), name='c')],
 )
-def test_consistent_protocols(observable, key):
+def test_consistent_protocols(observable, key) -> None:
     gate = cirq.PauliMeasurementGate(observable, key=key)
     cirq.testing.assert_implements_consistent_protocols(gate)
     assert cirq.is_measurement(gate)
     assert cirq.measurement_key_name(gate) == str(key)
 
 
-def test_op_repr():
+def test_op_repr() -> None:
     a, b, c = cirq.LineQubit.range(3)
     ps = cirq.X(a) * cirq.Y(b) * cirq.Z(c)
     assert (
@@ -152,12 +152,12 @@ def test_op_repr():
     )
 
 
-def test_bad_observable_raises():
+def test_bad_observable_raises() -> None:
     with pytest.raises(ValueError, match='Pauli observable .* is empty'):
         _ = cirq.PauliMeasurementGate([])
 
     with pytest.raises(ValueError, match=r'Pauli observable .* must be Iterable\[`cirq.Pauli`\]'):
-        _ = cirq.PauliMeasurementGate([cirq.I, cirq.X, cirq.Y])
+        _ = cirq.PauliMeasurementGate([cirq.I, cirq.X, cirq.Y])  # type: ignore[list-item]
 
     with pytest.raises(ValueError, match=r'Pauli observable .* must be Iterable\[`cirq.Pauli`\]'):
         _ = cirq.PauliMeasurementGate(cirq.DensePauliString('XYZI'))
@@ -166,7 +166,7 @@ def test_bad_observable_raises():
         _ = cirq.PauliMeasurementGate(cirq.DensePauliString('XYZ', coefficient=1j))
 
 
-def test_with_observable():
+def test_with_observable() -> None:
     o1 = [cirq.Z, cirq.Y, cirq.X]
     o2 = [cirq.X, cirq.Y, cirq.Z]
     g1 = cirq.PauliMeasurementGate(o1, key='a')
@@ -186,7 +186,7 @@ def test_with_observable():
         (cirq.X**-0.5, cirq.DensePauliString("Y", coefficient=-1), 1),
     ],
 )
-def test_pauli_measurement_gate_samples(rot, obs, out):
+def test_pauli_measurement_gate_samples(rot, obs, out) -> None:
     q = cirq.NamedQubit("q")
     c = cirq.Circuit(rot(q), cirq.PauliMeasurementGate(obs, key='out').on(q))
     assert cirq.Simulator().sample(c)['out'][0] == out