cirq-core 1.6.0.dev20250529194600__py3-none-any.whl → 1.6.0.dev20250530203656__py3-none-any.whl

cirq/ops/control_values_test.py

@@ -19,7 +19,7 @@ import pytest
 import cirq
 
 
-def test_init_sum_of_products_raises():
+def test_init_sum_of_products_raises() -> None:
     # data shouldn't be empty.
     with pytest.raises(ValueError):
         _ = cirq.SumOfProducts([])
@@ -29,7 +29,7 @@ def test_init_sum_of_products_raises():
         _ = cirq.SumOfProducts([[1], [1, 0]])
 
 
-def test_init_product_of_sums():
+def test_init_product_of_sums() -> None:
     eq = cirq.testing.EqualsTester()
     # 0. Trivial case of 1 control and 1 qubit.
     eq.add_equality_group(cirq.ProductOfSums([1]), cirq.ProductOfSums(((1,),)))
@@ -59,7 +59,7 @@ def test_init_product_of_sums():
     eq.add_equality_group([(1, 2), (0, 1)])
 
 
-def test_init_sum_of_products():
+def test_init_sum_of_products() -> None:
     eq = cirq.testing.EqualsTester()
     # 0. Trivial case of 1 control and 1 qubit
     eq.add_equality_group(cirq.SumOfProducts([[1]]), cirq.SumOfProducts(((1,),)))
@@ -90,7 +90,7 @@ def test_init_sum_of_products():
     eq.add_equality_group(cirq.SumOfProducts([(1, 0), (2, 0), (1, 1), (2, 1)]))
 
 
-def test_equality_across_types():
+def test_equality_across_types() -> None:
     eq = cirq.testing.EqualsTester()
     # Trivial case of 1 control and 1 qubit
     eq.add_equality_group(
@@ -124,7 +124,7 @@ def test_equality_across_types():
     eq.add_equality_group(cirq.ProductOfSums([(0, 1), (1, 0)]))  # or control
 
 
-def test_and_operation():
+def test_and_operation() -> None:
     eq = cirq.testing.EqualsTester()
 
     eq.add_equality_group(
@@ -171,12 +171,12 @@ def test_and_operation():
         [cirq.SumOfProducts([(0, 0), (1, 1)]), cirq.ProductOfSums([0, 1, 2]), cirq.SumOfProducts],
     ],
 )
-def test_and_operation_adds_qubits(cv1, cv2, expected_type):
+def test_and_operation_adds_qubits(cv1, cv2, expected_type) -> None:
     assert isinstance(cv1 & cv2, expected_type)
     assert cirq.num_qubits(cv1 & cv2) == cirq.num_qubits(cv1) + cirq.num_qubits(cv2)
 
 
-def test_or_operation():
+def test_or_operation() -> None:
     eq = cirq.testing.EqualsTester()
 
     eq.add_equality_group(
@@ -214,7 +214,7 @@ def test_or_operation():
         [cirq.SumOfProducts([[0], [1], [2]]), cirq.SumOfProducts([[1, 0]]), None],
     ],
 )
-def test_or_operation_acts_on_same_qubits(cv1, cv2, expected_type):
+def test_or_operation_acts_on_same_qubits(cv1, cv2, expected_type) -> None:
     if cirq.num_qubits(cv1) == cirq.num_qubits(cv2):
         assert cirq.num_qubits(cv1 | cv2) == cirq.num_qubits(cv1)
         assert expected_type is not None
@@ -226,17 +226,17 @@ def test_or_operation_acts_on_same_qubits(cv1, cv2, expected_type):
 
 
 @pytest.mark.parametrize('data', [((1,),), ((0, 1), (1,)), [(0, 1), (1, 0)]])
-def test_product_of_sums_repr(data):
+def test_product_of_sums_repr(data) -> None:
     cirq.testing.assert_equivalent_repr(cirq.ProductOfSums(data))
 
 
 @pytest.mark.parametrize('data', [((1,),), ((0, 1),), ((0, 0), (0, 1), (1, 0))])
-def test_sum_of_products_repr(data):
+def test_sum_of_products_repr(data) -> None:
     cirq.testing.assert_equivalent_repr(cirq.SumOfProducts(data))
     cirq.testing.assert_equivalent_repr(cirq.SumOfProducts(data, name="CustomName"))
 
 
-def test_sum_of_products_validate():
+def test_sum_of_products_validate() -> None:
     control_val = cirq.SumOfProducts(((1, 2), (0, 1)))
 
     control_val.validate([2, 3])
@@ -250,7 +250,7 @@ def test_sum_of_products_validate():
 
 
 @pytest.mark.parametrize('data', [((1,),), ((0, 1),), ((0, 0), (0, 1), (1, 0))])
-def test_sum_of_products_num_qubits(data):
+def test_sum_of_products_num_qubits(data) -> None:
     assert cirq.num_qubits(cirq.SumOfProducts(data)) == len(data[0])
 
 
@@ -263,7 +263,7 @@ def test_sum_of_products_num_qubits(data):
         [((1, 1, 1, 1),), True],
     ],
 )
-def test_sum_of_products_is_trivial(data, is_trivial):
+def test_sum_of_products_is_trivial(data, is_trivial) -> None:
     assert cirq.SumOfProducts(data).is_trivial == is_trivial
 
 
@@ -271,16 +271,16 @@ def test_sum_of_products_is_trivial(data, is_trivial):
     'data, is_trivial',
     [[((1,),), True], [((0, 1),), False], [([2], [1], [2]), False], [([1], [1], [1], [1]), True]],
 )
-def test_product_of_sum_is_trivial(data, is_trivial):
+def test_product_of_sum_is_trivial(data, is_trivial) -> None:
     assert cirq.ProductOfSums(data).is_trivial == is_trivial
 
 
-def test_product_of_sums_str():
+def test_product_of_sums_str() -> None:
     c = cirq.ProductOfSums([(0, 1), 1, 0, (0, 2)])
     assert str(c) == 'C01C1C0C02'
 
 
-def test_sum_of_products_str():
+def test_sum_of_products_str() -> None:
     c = cirq.SumOfProducts(((1, 0), (0, 1)))
     assert str(c) == 'C_01_10'
 
@@ -288,7 +288,7 @@ def test_sum_of_products_str():
     assert str(c) == 'C_xor'
 
 
-def test_control_values_diagrams():
+def test_control_values_diagrams() -> None:
     q = cirq.LineQubit.range(3)
     ccx = cirq.X(q[0]).controlled_by(*q[1:])
     ccx_sop = cirq.X(q[0]).controlled_by(*q[1:], control_values=cirq.SumOfProducts([[1, 1]]))

cirq/ops/controlled_gate_test.py

@@ -112,13 +112,13 @@ C_02_20H = cirq.ControlledGate(
 C2Restricted = cirq.ControlledGate(RestrictedGate(), control_values=[2], control_qid_shape=(3,))
 
 
-def test_init():
+def test_init() -> None:
     gate = cirq.ControlledGate(cirq.Z)
     assert gate.sub_gate is cirq.Z
     assert gate.num_qubits() == 2
 
 
-def test_init2():
+def test_init2() -> None:
     with pytest.raises(ValueError, match=r'cirq\.num_qubits\(control_values\) != num_controls'):
         cirq.ControlledGate(cirq.Z, num_controls=1, control_values=(1, 0))
     with pytest.raises(ValueError, match=r'len\(control_qid_shape\) != num_controls'):
@@ -188,7 +188,7 @@ def test_init2():
     assert cirq.qid_shape(gate) == (3, 3, 2)
 
 
-def test_validate_args():
+def test_validate_args() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -234,7 +234,7 @@ def test_validate_args():
     _ = C2C2H.on(q3, p3, a)
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(CY, cirq.ControlledGate(cirq.Y))
     eq.add_equality_group(CCH)
@@ -272,7 +272,7 @@ def test_eq():
                 np.testing.assert_allclose(cirq.unitary(item), cirq.unitary(group[0]))
 
 
-def test_control():
+def test_control() -> None:
     class G(cirq.testing.SingleQubitGate):
         def _has_mixture_(self):
             return True
@@ -301,7 +301,7 @@ def test_control():
     eq.add_equality_group(
         cirq.ControlledGate(g, num_controls=2),
         g.controlled(control_values=[1, 1]),
-        g.controlled(control_qid_shape=[2, 2]),
+        g.controlled(control_qid_shape=(2, 2)),
         g.controlled(num_controls=2),
         g.controlled().controlled(),
         g.controlled(control_values=cirq.SumOfProducts([[1, 1]])),
@@ -314,14 +314,14 @@ def test_control():
     )
     eq.add_equality_group(g.controlled(control_values=[0]).controlled(control_values=[1]))
     eq.add_equality_group(
-        cirq.ControlledGate(g, control_qid_shape=[4, 3]),
-        g.controlled(control_qid_shape=[4, 3]),
-        g.controlled(control_qid_shape=[3]).controlled(control_qid_shape=[4]),
+        cirq.ControlledGate(g, control_qid_shape=(4, 3)),
+        g.controlled(control_qid_shape=(4, 3)),
+        g.controlled(control_qid_shape=(3,)).controlled(control_qid_shape=(4,)),
     )
-    eq.add_equality_group(g.controlled(control_qid_shape=[4]).controlled(control_qid_shape=[3]))
+    eq.add_equality_group(g.controlled(control_qid_shape=(4,)).controlled(control_qid_shape=(3,)))
 
 
-def test_unitary():
+def test_unitary() -> None:
     cxa = cirq.ControlledGate(cirq.X ** sympy.Symbol('a'))
     assert not cirq.has_unitary(cxa)
     assert cirq.unitary(cxa, None) is None
@@ -426,7 +426,7 @@ def test_unitary():
         (C0C_xorH, False),
     ],
 )
-def test_controlled_gate_is_consistent(gate: cirq.Gate, should_decompose_to_target):
+def test_controlled_gate_is_consistent(gate: cirq.Gate, should_decompose_to_target) -> None:
     _test_controlled_gate_is_consistent(gate, should_decompose_to_target)
 
 
@@ -466,7 +466,7 @@ def test_nontrivial_controlled_gate_is_consistent(
     control_qid_shape: Sequence[int],
     control_values: Any,
     should_decompose_to_target: bool,
-):
+) -> None:
     _test_controlled_gate_is_consistent(
         gate, should_decompose_to_target, control_qid_shape, control_values
     )
@@ -511,7 +511,7 @@ def _test_controlled_gate_is_consistent(
 )
 def test_controlled_gate_decomposition_uses_canonical_version(
     sub_gate: cirq.Gate, expected_decomposition: list[cirq.Gate]
-):
+) -> None:
     cgate = cirq.ControlledGate(sub_gate, num_controls=1)
     qubits = cirq.LineQubit.range(1 + sub_gate.num_qubits())
     dec = cirq.decompose_once(cgate.on(*qubits))
@@ -523,14 +523,14 @@ def test_controlled_gate_decomposition_uses_canonical_version(
 )
 def test_controlled_gate_full_decomposition(
     sub_gate: cirq.Gate, expected_decomposition: list[cirq.Gate]
-):
+) -> None:
     cgate = cirq.ControlledGate(sub_gate, num_controls=1)
     qubits = cirq.LineQubit.range(1 + sub_gate.num_qubits())
     dec = cirq.decompose(cgate.on(*qubits))
     assert dec == [gate.on(*qubits) for gate in expected_decomposition]
 
 
-def test_pow_inverse():
+def test_pow_inverse() -> None:
     assert cirq.inverse(CRestricted, None) is None
     assert cirq.pow(CRestricted, 1.5, None) is None
     assert cirq.pow(CY, 1.5) == cirq.ControlledGate(cirq.Y**1.5)
@@ -549,7 +549,7 @@ def test_pow_inverse():
     assert cirq.inverse(C2Y) == C2Y**-1 == C2Y
 
 
-def test_extrapolatable_effect():
+def test_extrapolatable_effect() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -560,7 +560,7 @@ def test_extrapolatable_effect():
     assert cirq.ControlledGate(cirq.Z) ** 0.5 == cirq.ControlledGate(cirq.Z**0.5)
 
 
-def test_reversible():
+def test_reversible() -> None:
     assert cirq.inverse(cirq.ControlledGate(cirq.S)) == cirq.ControlledGate(cirq.S**-1)
     assert cirq.inverse(cirq.ControlledGate(cirq.S, num_controls=4)) == cirq.ControlledGate(
         cirq.S**-1, num_controls=4
@@ -578,7 +578,7 @@ class UnphaseableGate(cirq.Gate):
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_parameterizable(resolve_fn):
+def test_parameterizable(resolve_fn) -> None:
     a = sympy.Symbol('a')
     cy = cirq.ControlledGate(cirq.Y)
     cya = cirq.ControlledGate(cirq.YPowGate(exponent=a))
@@ -593,7 +593,7 @@ def test_parameterizable(resolve_fn):
         resolve_fn(cchan, cirq.ParamResolver({'a': 0.1}))
 
 
-def test_circuit_diagram_info():
+def test_circuit_diagram_info() -> None:
     assert cirq.circuit_diagram_info(CY) == cirq.CircuitDiagramInfo(
         wire_symbols=('@', 'Y'), exponent=1
     )
@@ -645,7 +645,7 @@ class MultiH(cirq.Gate):
         return True
 
 
-def test_circuit_diagram_product_of_sums():
+def test_circuit_diagram_product_of_sums() -> None:
     qubits = cirq.LineQubit.range(3)
     c = cirq.Circuit()
     c.append(cirq.ControlledGate(MultiH(2))(*qubits))
@@ -661,9 +661,9 @@ def test_circuit_diagram_product_of_sums():
 """,
     )
 
-    qubits = cirq.LineQid.for_qid_shape((3, 3, 3, 2))
+    qids = cirq.LineQid.for_qid_shape((3, 3, 3, 2))
     c = cirq.Circuit(
-        MultiH(1)(*qubits[3:]).controlled_by(*qubits[:3], control_values=[1, (0, 1), (2, 0)])
+        MultiH(1)(*qids[3:]).controlled_by(*qids[:3], control_values=[1, (0, 1), (2, 0)])
     )
 
     cirq.testing.assert_has_diagram(
@@ -680,7 +680,7 @@ def test_circuit_diagram_product_of_sums():
     )
 
 
-def test_circuit_diagram_sum_of_products():
+def test_circuit_diagram_sum_of_products() -> None:
     q = cirq.LineQubit.range(4)
     c = cirq.Circuit(C_xorH.on(*q[:3]), C_01_10_11H.on(*q[:3]), C0C_xorH.on(*q))
     cirq.testing.assert_has_diagram(
@@ -695,8 +695,8 @@ def test_circuit_diagram_sum_of_products():
 3: ─────────────────────H───────
 """,
     )
-    q = cirq.LineQid.for_qid_shape((2, 3, 2))
-    c = cirq.Circuit(C_02_20H(*q))
+    qid = cirq.LineQid.for_qid_shape((2, 3, 2))
+    c = cirq.Circuit(C_02_20H(*qid))
     cirq.testing.assert_has_diagram(
         c,
         """
@@ -718,7 +718,7 @@ class MockGate(cirq.testing.TwoQubitGate):
         return True
 
 
-def test_uninformed_circuit_diagram_info():
+def test_uninformed_circuit_diagram_info() -> None:
     qbits = cirq.LineQubit.range(3)
     mock_gate = MockGate()
     cgate = cirq.ControlledGate(mock_gate)(*qbits)
@@ -731,7 +731,7 @@ def test_uninformed_circuit_diagram_info():
     assert mock_gate.captured_diagram_args == args
 
 
-def test_bounded_effect():
+def test_bounded_effect() -> None:
     assert cirq.trace_distance_bound(CY**0.001) < 0.01
     assert cirq.approx_eq(cirq.trace_distance_bound(CCH), 1.0)
     foo = sympy.Symbol('foo')
@@ -751,11 +751,11 @@ def test_bounded_effect():
         C_02_20H,
     ],
 )
-def test_repr(gate):
+def test_repr(gate) -> None:
     cirq.testing.assert_equivalent_repr(gate)
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.ControlledGate(cirq.X)) == 'CX'
     assert str(cirq.ControlledGate(cirq.Z)) == 'CZ'
     assert str(cirq.ControlledGate(cirq.S)) == 'CS'
@@ -769,7 +769,7 @@ def test_str():
     assert str(C2Restricted) == 'C2Restricted'
 
 
-def test_controlled_mixture():
+def test_controlled_mixture() -> None:
     c_yes = cirq.ControlledGate(sub_gate=cirq.phase_flip(0.25), num_controls=1)
     assert cirq.has_mixture(c_yes)
     assert cirq.approx_eq(cirq.mixture(c_yes), [(0.75, np.eye(4)), (0.25, cirq.unitary(cirq.CZ))])
@@ -786,7 +786,9 @@ def test_controlled_mixture():
         (4, -np.pi / 3, ((0,), (1,), (1,), (0,))),
     ],
 )
-def test_controlled_global_phase_matrix_gate_decomposes(num_controls, angle, control_values):
+def test_controlled_global_phase_matrix_gate_decomposes(
+    num_controls, angle, control_values
+) -> None:
     all_qubits = cirq.LineQubit.range(num_controls)
     control_values = cirq.ops.control_values.ProductOfSums(control_values)
     control_qid_shape = (2,) * num_controls

cirq/ops/diagonal_gate_test.py

@@ -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)

cirq/ops/eigen_gate_test.py

@@ -58,7 +58,7 @@ class ZGateDef(cirq.EigenGate, cirq.testing.SingleQubitGate):
         return [(0, np.diag([1, 0])), (1, np.diag([0, 1]))]
 
 
-def test_approximate_common_period():
+def test_approximate_common_period() -> None:
     from cirq.ops.eigen_gate import _approximate_common_period as f
 
     assert f([]) is None
@@ -71,13 +71,19 @@ def test_approximate_common_period():
     assert f([2.5]) == 2.5
     assert f([1.5, 2]) == 6
     assert f([2, 3]) == 6
-    assert abs(f([1 / 3, 2 / 3]) - 2 / 3) < 1e-8
-    assert abs(f([2 / 5, 3 / 5]) - 6 / 5) < 1e-8
+    f_x = f([1 / 3, 2 / 3])
+    assert f_x is not None
+    assert abs(f_x - 2 / 3) < 1e-8
+    f_x = f([2 / 5, 3 / 5])
+    assert f_x is not None
+    assert abs(f_x - 6 / 5) < 1e-8
     assert f([0.5, -0.5]) == 0.5
-    np.testing.assert_allclose(f([np.e]), np.e, atol=1e-8)
+    f_x = f([np.e])
+    assert f_x is not None
+    np.testing.assert_allclose(f_x, np.e, atol=1e-8)
 
 
-def test_init():
+def test_init() -> None:
     assert CExpZinGate(1).exponent == 1
     assert CExpZinGate(0.5).exponent == 0.5
     assert CExpZinGate(4.5).exponent == 4.5
@@ -91,7 +97,7 @@ def test_init():
     assert ZGateDef(exponent=0.5 + 0j).exponent == 0.5
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(lambda: CExpZinGate(quarter_turns=0.1))
     eq.add_equality_group(CExpZinGate(0), CExpZinGate(4), CExpZinGate(-4))
@@ -166,7 +172,7 @@ def test_eq():
     )
 
 
-def test_approx_eq():
+def test_approx_eq() -> None:
     assert cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(1.5), atol=0.1)
     assert cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(1.7), atol=0.3)
     assert not cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(1.7), atol=0.1)
@@ -188,7 +194,7 @@ def test_approx_eq():
         )
 
 
-def test_approx_eq_periodic():
+def test_approx_eq_periodic() -> None:
     assert cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(5.5), atol=1e-9)
     assert cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(9.5), atol=1e-9)
     assert cirq.approx_eq(CExpZinGate(-2.5), CExpZinGate(1.5), atol=1e-9)
@@ -199,7 +205,7 @@ def test_approx_eq_periodic():
     assert cirq.approx_eq(CExpZinGate(0), CExpZinGate(4 - 1e-10), atol=1e-9)
 
 
-def test_period():
+def test_period() -> None:
     class Components(cirq.EigenGate, cirq.testing.TwoQubitGate):
         def __init__(self, a, b, c, d):
             super().__init__()
@@ -224,14 +230,16 @@ def test_period():
     assert Components(1 / 3, 1 / 2, 1 / 5, 0)._period() == 60
     assert Components(1 / 6, 1 / 2, 1 / 5, 0)._period() == 60
     assert Components(np.e, np.pi, 0, 0)._period() is None
-    np.testing.assert_allclose(Components(np.e, np.e, 0, 0)._period(), 2 / np.e)
+    period = Components(np.e, np.e, 0, 0)._period()
+    assert period is not None
+    np.testing.assert_allclose(period, 2 / np.e)
     assert Components(-0.5, 0, 0, 0)._period() == 4
     assert Components(-0.5, 0.5, 0, 0)._period() == 4
     assert Components(-0.5, 0.5, 0.5, 0.5)._period() == 4
     assert Components(1, 1, -1, 1)._period() == 2
 
 
-def test_pow():
+def test_pow() -> None:
     assert CExpZinGate(0.25) ** 2 == CExpZinGate(0.5)
     assert CExpZinGate(0.25) ** -1 == CExpZinGate(-0.25)
     assert CExpZinGate(0.25) ** 0 == CExpZinGate(0)
@@ -245,12 +253,12 @@ def test_pow():
     assert ZGateDef(exponent=0.5) ** (1 + 0j) == ZGateDef(exponent=0.5)
 
 
-def test_inverse():
+def test_inverse() -> None:
     assert cirq.inverse(CExpZinGate(0.25)) == CExpZinGate(-0.25)
     assert cirq.inverse(CExpZinGate(sympy.Symbol('a'))) == CExpZinGate(-sympy.Symbol('a'))
 
 
-def test_trace_distance_bound():
+def test_trace_distance_bound() -> None:
     assert cirq.trace_distance_bound(CExpZinGate(0.001)) < 0.01
     assert cirq.trace_distance_bound(CExpZinGate(sympy.Symbol('a'))) == 1
     assert cirq.approx_eq(cirq.trace_distance_bound(CExpZinGate(2)), 1)
@@ -266,7 +274,7 @@ def test_trace_distance_bound():
         assert_has_consistent_trace_distance_bound(E() ** (numerator / 12))
 
 
-def test_extrapolate():
+def test_extrapolate() -> None:
     h = CExpZinGate(2)
     assert cirq.pow(h, 1.5) is not None
     assert cirq.inverse(h, None) is not None
@@ -280,7 +288,7 @@ def test_extrapolate():
     assert cirq.inverse(s) == CExpZinGate(-sympy.Symbol('a'))
 
 
-def test_matrix():
+def test_matrix() -> None:
     for n in [1, 2, 3, 4, 0.0001, 3.9999]:
         assert cirq.has_unitary(CExpZinGate(n))
 
@@ -326,11 +334,11 @@ def test_matrix():
     )
 
 
-def test_matrix_is_exact_for_quarter_turn():
+def test_matrix_is_exact_for_quarter_turn() -> None:
     np.testing.assert_equal(cirq.unitary(CExpZinGate(1)), np.diag([1, 1, 1j, -1j]))
 
 
-def test_is_parameterized():
+def test_is_parameterized() -> None:
     assert not cirq.is_parameterized(CExpZinGate(0))
     assert not cirq.is_parameterized(CExpZinGate(1))
     assert not cirq.is_parameterized(CExpZinGate(3))
@@ -338,7 +346,7 @@ def test_is_parameterized():
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_resolve_parameters(resolve_fn):
+def test_resolve_parameters(resolve_fn) -> None:
     assert resolve_fn(
         CExpZinGate(sympy.Symbol('a')), cirq.ParamResolver({'a': 0.5})
     ) == CExpZinGate(0.5)
@@ -349,7 +357,7 @@ def test_resolve_parameters(resolve_fn):
         resolve_fn(CExpZinGate(sympy.Symbol('a')), cirq.ParamResolver({'a': 0.5j}))
 
 
-def test_diagram_period():
+def test_diagram_period() -> None:
     class ShiftyGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
         def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
             raise NotImplementedError()
@@ -419,5 +427,5 @@ class WeightedZPowGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
         (cirq.Z**2, cirq.Z ** (4 + 1e-10), True),
     ],
 )
-def test_equal_up_to_global_phase(gate1, gate2, eq_up_to_global_phase):
+def test_equal_up_to_global_phase(gate1, gate2, eq_up_to_global_phase) -> None:
     assert cirq.equal_up_to_global_phase(gate1, gate2) == eq_up_to_global_phase

cirq/ops/fourier_transform.py

@@ -212,6 +212,4 @@ def qft(*qubits: cirq.Qid, without_reverse: bool = False, inverse: bool = False)
         A `cirq.Operation` applying the qft to the given qubits.
     """
     result = QuantumFourierTransformGate(len(qubits), without_reverse=without_reverse).on(*qubits)
-    if inverse:
-        result = cirq.inverse(result)
-    return result
+    return cirq.inverse(result) if inverse else result