cirq-core 1.7.0.dev20251002223432__py3-none-any.whl → 1.7.0.dev20251007180852__py3-none-any.whl

cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap_test.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import itertools
+from typing import Iterator
 
 import numpy as np
 import pytest
@@ -23,11 +24,11 @@ import sympy
 import cirq
 
 
-def random_unitary(seed):
+def random_unitary(seed: cirq.RANDOM_STATE_OR_SEED_LIKE) -> np.ndarray:
     return cirq.testing.random_unitary(4, random_state=seed)
 
 
-def random_locals(x, y, z, seed=None):
+def random_locals(x: float, y: float, z: float, seed=None) -> np.ndarray:
     rng = np.random.RandomState(seed)
     a0 = cirq.testing.random_unitary(2, random_state=rng)
     a1 = cirq.testing.random_unitary(2, random_state=rng)
@@ -42,15 +43,14 @@ def random_locals(x, y, z, seed=None):
     )
 
 
-def perturbations_unitary(u, amount=1e-10):
+def perturbations_unitary(u: np.ndarray, amount=1e-10) -> Iterator[np.ndarray]:
     """Returns several unitaries in the neighborhood of u to test for numerical
     corner cases near critical values."""
     kak = cirq.kak_decomposition(u)
     yield u
     for i in range(3):
         for neg in (-1, 1):
-            perturb_xyz = list(kak.interaction_coefficients)
-            perturb_xyz[i] += neg * amount
+            perturb_xyz = tuple(c + neg * amount for c in kak.interaction_coefficients)
             yield cirq.unitary(
                 cirq.KakDecomposition(
                     global_phase=kak.global_phase,
@@ -61,11 +61,11 @@ def perturbations_unitary(u, amount=1e-10):
             )
 
 
-def perturbations_gate(gate, amount=1e-10):
+def perturbations_gate(gate: cirq.SupportsUnitary, amount=1e-10) -> Iterator[np.ndarray]:
     return perturbations_unitary(cirq.unitary(gate), amount)
 
 
-def perturbations_weyl(x, y, z, amount=1e-10):
+def perturbations_weyl(x: float, y: float, z: float, amount: float = 1e-10) -> Iterator[np.ndarray]:
     return perturbations_gate(cirq.KakDecomposition(interaction_coefficients=(x, y, z)), amount)
 
 
@@ -211,7 +211,7 @@ def assert_valid_decomp(
     atol=1e-6,
     rtol=0,
     qubit_order=cirq.LineQubit.range(2),
-):
+) -> None:
     # Check expected gates
     for op in operations:
         if len(op.qubits) == 0 and isinstance(op.gate, cirq.GlobalPhaseGate):
@@ -242,7 +242,7 @@ def assert_valid_decomp(
         )
 
 
-def assert_specific_sqrt_iswap_count(operations, count):
+def assert_specific_sqrt_iswap_count(operations, count) -> None:
     actual = sum(len(op.qubits) == 2 for op in operations)
     assert actual == count, f'Incorrect sqrt-iSWAP count.  Expected {count} but got {actual}.'
 
@@ -255,7 +255,7 @@ def assert_specific_sqrt_iswap_count(operations, count):
         cirq.CZPowGate(exponent=sympy.Symbol('t')),
     ],
 )
-def test_two_qubit_gates_with_symbols(gate: cirq.Gate):
+def test_two_qubit_gates_with_symbols(gate: cirq.Gate) -> None:
     op = gate(*cirq.LineQubit.range(2))
     c_new_sqrt_iswap = cirq.Circuit(
         cirq.parameterized_2q_op_to_sqrt_iswap_operations(op)  # type: ignore
@@ -279,12 +279,14 @@ def test_two_qubit_gates_with_symbols(gate: cirq.Gate):
         )
 
 
-def test_fsim_gate_with_symbols():
+def test_fsim_gate_with_symbols() -> None:
     theta, phi = sympy.symbols(['theta', 'phi'])
     op = cirq.FSimGate(theta=theta, phi=phi).on(*cirq.LineQubit.range(2))
-    c_new_sqrt_iswap = cirq.Circuit(cirq.parameterized_2q_op_to_sqrt_iswap_operations(op))
+    c_new_sqrt_iswap = cirq.Circuit(
+        cirq.parameterized_2q_op_to_sqrt_iswap_operations(op)  # type: ignore[arg-type]
+    )
     c_new_sqrt_iswap_inv = cirq.Circuit(
-        cirq.parameterized_2q_op_to_sqrt_iswap_operations(op, use_sqrt_iswap_inv=True)
+        cirq.parameterized_2q_op_to_sqrt_iswap_operations(op, use_sqrt_iswap_inv=True)  # type: ignore[arg-type]
     )
     for theta_val in np.linspace(0, 2 * np.pi, 4):
         for phi_val in np.linspace(0, 2 * np.pi, 6):
@@ -307,7 +309,7 @@ def test_fsim_gate_with_symbols():
 
 
 @pytest.mark.parametrize('cnt', [-1, 4, 10])
-def test_invalid_required_sqrt_iswap_count(cnt):
+def test_invalid_required_sqrt_iswap_count(cnt) -> None:
     u = TWO_SQRT_ISWAP_UNITARIES[0]
     q0, q1 = cirq.LineQubit.range(2)
     with pytest.raises(ValueError, match='required_sqrt_iswap_count'):
@@ -315,7 +317,7 @@ def test_invalid_required_sqrt_iswap_count(cnt):
 
 
 @pytest.mark.parametrize('u', ZERO_UNITARIES)
-def test_decomp0(u):
+def test_decomp0(u) -> None:
     # Decompose unitaries into zero sqrt-iSWAP gates
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, required_sqrt_iswap_count=0)
@@ -326,7 +328,7 @@ def test_decomp0(u):
 @pytest.mark.parametrize(
     'u', ONE_SQRT_ISWAP_UNITARIES + TWO_SQRT_ISWAP_UNITARIES + THREE_SQRT_ISWAP_UNITARIES
 )
-def test_decomp0_invalid(u):
+def test_decomp0_invalid(u) -> None:
     # Attempt to decompose other unitaries into zero SQRT_ISWAP gates
     q0, q1 = cirq.LineQubit.range(2)
     with pytest.raises(ValueError, match='cannot be decomposed into exactly 0 sqrt-iSWAP gates'):
@@ -334,7 +336,7 @@ def test_decomp0_invalid(u):
 
 
 @pytest.mark.parametrize('u', ONE_SQRT_ISWAP_UNITARIES)
-def test_decomp1(u):
+def test_decomp1(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, required_sqrt_iswap_count=1)
     assert_valid_decomp(u, ops)
@@ -344,14 +346,14 @@ def test_decomp1(u):
 @pytest.mark.parametrize(
     'u', ZERO_UNITARIES + TWO_SQRT_ISWAP_UNITARIES + THREE_SQRT_ISWAP_UNITARIES
 )
-def test_decomp1_invalid(u):
+def test_decomp1_invalid(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     with pytest.raises(ValueError, match='cannot be decomposed into exactly 1 sqrt-iSWAP gates'):
         cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, required_sqrt_iswap_count=1)
 
 
 @pytest.mark.parametrize('u', ZERO_UNITARIES + ONE_SQRT_ISWAP_UNITARIES + TWO_SQRT_ISWAP_UNITARIES)
-def test_decomp2(u):
+def test_decomp2(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, required_sqrt_iswap_count=2)
     assert_valid_decomp(u, ops)
@@ -359,7 +361,7 @@ def test_decomp2(u):
 
 
 @pytest.mark.parametrize('u', THREE_SQRT_ISWAP_UNITARIES)
-def test_decomp2_invalid(u):
+def test_decomp2_invalid(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     with pytest.raises(ValueError, match='cannot be decomposed into exactly 2 sqrt-iSWAP gates'):
         cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, required_sqrt_iswap_count=2)
@@ -372,14 +374,14 @@ def test_decomp2_invalid(u):
     + TWO_SQRT_ISWAP_UNITARIES
     + THREE_SQRT_ISWAP_UNITARIES,
 )
-def test_decomp3(u):
+def test_decomp3(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, required_sqrt_iswap_count=3)
     assert_valid_decomp(u, ops)
     assert_specific_sqrt_iswap_count(ops, 3)
 
 
-def test_decomp3_invalid():
+def test_decomp3_invalid() -> None:
     # All two-qubit gates can be synthesized with three SQRT_ISWAP gates
     u = cirq.unitary(cirq.X**0.2)  # Pass an invalid size unitary
     q0, q1 = cirq.LineQubit.range(2)
@@ -388,7 +390,7 @@ def test_decomp3_invalid():
 
 
 @pytest.mark.parametrize('u', TWO_SQRT_ISWAP_UNITARIES[:1])
-def test_qubit_order(u):
+def test_qubit_order(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q1, q0, u, required_sqrt_iswap_count=2)
     assert_valid_decomp(u, ops, qubit_order=(q1, q0))
@@ -396,7 +398,7 @@ def test_qubit_order(u):
 
 
 @pytest.mark.parametrize('u', ZERO_UNITARIES)
-def test_decomp_optimal0(u):
+def test_decomp_optimal0(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u)
     assert_valid_decomp(u, ops)
@@ -404,7 +406,7 @@ def test_decomp_optimal0(u):
 
 
 @pytest.mark.parametrize('u', ONE_SQRT_ISWAP_UNITARIES)
-def test_decomp_optimal1(u):
+def test_decomp_optimal1(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u)
     assert_valid_decomp(u, ops)
@@ -412,7 +414,7 @@ def test_decomp_optimal1(u):
 
 
 @pytest.mark.parametrize('u', TWO_SQRT_ISWAP_UNITARIES)
-def test_decomp_optimal2(u):
+def test_decomp_optimal2(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u)
     assert_valid_decomp(u, ops)
@@ -420,7 +422,7 @@ def test_decomp_optimal2(u):
 
 
 @pytest.mark.parametrize('u', THREE_SQRT_ISWAP_UNITARIES)
-def test_decomp_optimal3(u):
+def test_decomp_optimal3(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u)
     assert_valid_decomp(u, ops)
@@ -428,7 +430,7 @@ def test_decomp_optimal3(u):
 
 
 @pytest.mark.parametrize('u', ALL_REGION_UNITARIES)
-def test_all_weyl_regions(u):
+def test_all_weyl_regions(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, clean_operations=True)
     assert_valid_decomp(u, ops, single_qubit_gate_types=(cirq.PhasedXZGate,))
@@ -445,13 +447,13 @@ def test_all_weyl_regions(u):
         THREE_SQRT_ISWAP_UNITARIES[0],
     ],
 )
-def test_decomp_sqrt_iswap_inv(u):
+def test_decomp_sqrt_iswap_inv(u) -> None:
     q0, q1 = cirq.LineQubit.range(2)
     ops = cirq.two_qubit_matrix_to_sqrt_iswap_operations(q0, q1, u, use_sqrt_iswap_inv=True)
     assert_valid_decomp(u, ops, two_qubit_gate=cirq.SQRT_ISWAP_INV)
 
 
-def test_valid_check_raises():
+def test_valid_check_raises() -> None:
     q0 = cirq.LineQubit(0)
     with pytest.raises(AssertionError, match='Unitaries are completely different'):
         assert_valid_decomp(np.eye(4), [cirq.X(q0)], single_qubit_gate_types=(cirq.XPowGate,))

cirq/transformers/drop_negligible_operations_test.py

@@ -19,13 +19,13 @@ import cirq
 NO_COMPILE_TAG = "no_compile_tag"
 
 
-def test_leaves_big():
+def test_leaves_big() -> None:
     a = cirq.NamedQubit('a')
     circuit = cirq.Circuit(cirq.Moment(cirq.Z(a) ** 0.1))
     cirq.testing.assert_same_circuits(cirq.drop_negligible_operations(circuit, atol=0.001), circuit)
 
 
-def test_clears_small():
+def test_clears_small() -> None:
     a = cirq.NamedQubit('a')
     circuit = cirq.Circuit(cirq.Moment(cirq.Z(a) ** 0.000001))
     cirq.testing.assert_same_circuits(
@@ -33,7 +33,7 @@ def test_clears_small():
     )
 
 
-def test_does_not_clear_small_no_compile():
+def test_does_not_clear_small_no_compile() -> None:
     a = cirq.NamedQubit('a')
     circuit = cirq.Circuit(cirq.Moment((cirq.Z(a) ** 0.000001).with_tags(NO_COMPILE_TAG)))
     cirq.testing.assert_same_circuits(
@@ -44,7 +44,7 @@ def test_does_not_clear_small_no_compile():
     )
 
 
-def test_clears_known_empties_even_at_zero_tolerance():
+def test_clears_known_empties_even_at_zero_tolerance() -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(
         cirq.Z(a) ** 0, cirq.Y(a) ** 0.0000001, cirq.X(a) ** -0.0000001, cirq.CZ(a, b) ** 0
@@ -63,7 +63,7 @@ def test_clears_known_empties_even_at_zero_tolerance():
     )
 
 
-def test_recursively_runs_inside_circuit_ops_deep():
+def test_recursively_runs_inside_circuit_ops_deep() -> None:
     a = cirq.NamedQubit('a')
     small_op = cirq.Z(a) ** 0.000001
     nested_circuit = cirq.FrozenCircuit(
@@ -92,13 +92,13 @@ def test_recursively_runs_inside_circuit_ops_deep():
         ),
         cirq.Moment(),
     )
-    context = cirq.TransformerContext(tags_to_ignore=[NO_COMPILE_TAG], deep=True)
+    context = cirq.TransformerContext(tags_to_ignore=(NO_COMPILE_TAG,), deep=True)
     cirq.testing.assert_same_circuits(
         cirq.drop_negligible_operations(c_orig, context=context, atol=0.001), c_expected
     )
 
 
-def test_ignores_large_ops():
+def test_ignores_large_ops() -> None:
     qnum = 20
     qubits = cirq.LineQubit.range(qnum)
     subcircuit = cirq.FrozenCircuit(cirq.X.on_each(*qubits))

cirq/transformers/dynamical_decoupling_test.py

@@ -23,7 +23,7 @@ import cirq
 from cirq import add_dynamical_decoupling, CNOT, CZ, CZPowGate, H, X, Y, Z
 
 
-def assert_sim_eq(circuit1: cirq.AbstractCircuit, circuit2: cirq.AbstractCircuit):
+def assert_sim_eq(circuit1: cirq.AbstractCircuit, circuit2: cirq.AbstractCircuit) -> None:
     # Simulate 2 circuits and compare final states.
     sampler = cirq.Simulator(dtype=np.complex128)
     psi0 = sampler.simulate(cirq.drop_terminal_measurements(circuit1)).final_state_vector
@@ -37,7 +37,7 @@ def assert_dd(
     expected_circuit: str | cirq.AbstractCircuit,
     schema: str | tuple[cirq.Gate, ...] = 'DEFAULT',
     single_qubit_gate_moments_only: bool = True,
-):
+) -> None:
     transformed_circuit = add_dynamical_decoupling(
         input_circuit, schema=schema, single_qubit_gate_moments_only=single_qubit_gate_moments_only
     ).freeze()
@@ -53,7 +53,7 @@ def assert_dd(
     assert_sim_eq(input_circuit, transformed_circuit)
 
 
-def test_no_insertion():
+def test_no_insertion() -> None:
     """Test case diagrams.
     Input:
     a: ───H───@───────
@@ -81,7 +81,7 @@ def test_no_insertion():
     'schema,inserted_gates',
     [('XX_PAIR', (X, X)), ('X_XINV', (X, X**-1)), ('YY_PAIR', (Y, Y)), ('Y_YINV', (Y, Y**-1))],
 )
-def test_insert_provided_schema(schema: str, inserted_gates: Sequence[cirq.Gate]):
+def test_insert_provided_schema(schema: str, inserted_gates: Sequence[cirq.Gate]) -> None:
     """Test case diagrams.
     Input:
     a: ───H───@───────────M───
@@ -113,7 +113,7 @@ def test_insert_provided_schema(schema: str, inserted_gates: Sequence[cirq.Gate]
     assert_dd(input_circuit, expected_circuit, schema=schema, single_qubit_gate_moments_only=False)
 
 
-def test_insert_by_customized_dd_sequence():
+def test_insert_by_customized_dd_sequence() -> None:
     """Test case diagrams.
         Input:
     a: ───H───@───────────────────H───
@@ -151,13 +151,13 @@ def test_insert_by_customized_dd_sequence():
             cirq.Moment(CNOT(b, c), Y(a)),
             cirq.Moment([H(qubit) for qubit in [a, b, c]]),
         ),
-        schema=[X, X, Y, Y],
+        schema=(X, X, Y, Y),
         single_qubit_gate_moments_only=False,
     )
 
 
 @pytest.mark.parametrize('single_qubit_gate_moments_only', [True, False])
-def test_pull_through_h_gate_case1(single_qubit_gate_moments_only: bool):
+def test_pull_through_h_gate_case1(single_qubit_gate_moments_only: bool) -> None:
     """Test case diagrams.
     Input:
     a: ───H───────H───────@───
@@ -193,7 +193,7 @@ def test_pull_through_h_gate_case1(single_qubit_gate_moments_only: bool):
 
 
 @pytest.mark.parametrize('single_qubit_gate_moments_only', [True, False])
-def test_pull_through_h_gate_case2(single_qubit_gate_moments_only: bool):
+def test_pull_through_h_gate_case2(single_qubit_gate_moments_only: bool) -> None:
     """Test case diagrams.
     Input:
     a: ───H───────H───────H───
@@ -246,14 +246,14 @@ def test_pull_through_h_gate_case2(single_qubit_gate_moments_only: bool):
         ),
     ],
 )
-def test_invalid_dd_schema(schema: str | tuple[cirq.Gate, ...], error_msg_regex):
+def test_invalid_dd_schema(schema: str | tuple[cirq.Gate, ...], error_msg_regex) -> None:
     a = cirq.NamedQubit('a')
     input_circuit = cirq.Circuit(H(a))
     with pytest.raises(ValueError, match=error_msg_regex):
         add_dynamical_decoupling(input_circuit, schema=schema, single_qubit_gate_moments_only=False)
 
 
-def test_single_qubit_gate_moments_only_no_updates_succeeds():
+def test_single_qubit_gate_moments_only_no_updates_succeeds() -> None:
     qubits = cirq.LineQubit.range(9)
     input_circuit = cirq.Circuit(
         cirq.Moment([H(qubits[i]) for i in [3, 4, 5]]),
@@ -269,7 +269,7 @@ def test_single_qubit_gate_moments_only_no_updates_succeeds():
     add_dynamical_decoupling(input_circuit, schema='X_XINV', single_qubit_gate_moments_only=True)
 
 
-def test_scattered_circuit():
+def test_scattered_circuit() -> None:
     """Test case diagrams.
     Input:
     0: ───────────────────────────────H───@───H───
@@ -424,7 +424,7 @@ def test_scattered_circuit():
     )
 
 
-def test_scattered_circuit2():
+def test_scattered_circuit2() -> None:
     """Test case diagrams.
     Input:
     0: ───────────────────@───
@@ -484,7 +484,7 @@ def test_scattered_circuit2():
     )
 
 
-def test_pull_through_chain():
+def test_pull_through_chain() -> None:
     """Test case diagrams.
     Input:
     0: ───X───────×───────────X───
@@ -526,7 +526,7 @@ def test_pull_through_chain():
     )
 
 
-def test_multiple_clifford_pieces_case1():
+def test_multiple_clifford_pieces_case1() -> None:
     """Test case diagrams.
     Input:
     a: ───H───────H───────@───────────H───────H───
@@ -560,7 +560,7 @@ b: ───H───H───H───H───────@^0.5───H
     )
 
 
-def test_multiple_clifford_pieces_case2():
+def test_multiple_clifford_pieces_case2() -> None:
     """Test case diagrams.
     Input:
     a: ───@───PhXZ(a=0.3,x=0.2,z=0)───PhXZ(a=0.3,x=0.2,z=0)───PhXZ(a=0.3,x=0.2,z=0)───@───
@@ -596,7 +596,7 @@ def test_multiple_clifford_pieces_case2():
     )
 
 
-def test_insert_new_moment():
+def test_insert_new_moment() -> None:
     """Test case diagrams.
     Input:
     a: ───H───────H───@───@───────
@@ -637,7 +637,7 @@ def test_insert_new_moment():
     )
 
 
-def test_with_non_clifford_measurements():
+def test_with_non_clifford_measurements() -> None:
     """Test case diagrams.
     Input:
     0: ───────────H───@───H───M───
@@ -672,7 +672,7 @@ def test_with_non_clifford_measurements():
     )
 
 
-def test_cross_clifford_pieces_filling_merge():
+def test_cross_clifford_pieces_filling_merge() -> None:
     """Test case diagrams.
     Input:
     0: ─────────────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@─────────────────────────PhXZ(a=0.2,x=0.2,z=0.1)───@───PhXZ(a=0.2,x=0.2,z=0.1)───H───
@@ -738,7 +738,7 @@ def test_cross_clifford_pieces_filling_merge():
     )
 
 
-def test_pull_through_phxz_gate_case1():
+def test_pull_through_phxz_gate_case1() -> None:
     """Test case diagrams.
         Input:
     a: ───H───────PhXZ(a=0.25,x=-1,z=0)───────@───
@@ -767,7 +767,7 @@ b: ───H───H───H───────────────
     )
 
 
-def test_pull_through_phxz_gate_case2():
+def test_pull_through_phxz_gate_case2() -> None:
     """Test case diagrams.
         Input:
     a: ───H───────PhXZ(a=0.2,x=-1,z=0)───────@───
@@ -796,7 +796,7 @@ b: ───H───H───H───────────────
     )
 
 
-def test_merge_before_non_cliffords():
+def test_merge_before_non_cliffords() -> None:
     """Test case diagrams.
     Input circuit:
     0: ───X──────────────────────────────────────────────────M───
@@ -860,7 +860,7 @@ def test_merge_before_non_cliffords():
 )
 def test_single_qubit_gate_moments_only_true_vs_false(
     single_qubit_gate_moments_only, expected_diagram
-):
+) -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     input_circuit = cirq.Circuit(
         cirq.Moment([X(q) for q in [q0, q1, q2]]),

cirq/transformers/eject_phased_paulis_test.py

@@ -31,7 +31,7 @@ def assert_optimizes(
     eject_parameterized: bool = False,
     *,
     with_context: bool = False,
-):
+) -> None:
     context = cirq.TransformerContext(tags_to_ignore=("nocompile",)) if with_context else None
     circuit = cirq.eject_phased_paulis(
         before, eject_parameterized=eject_parameterized, context=context

cirq/transformers/eject_z.py

@@ -29,11 +29,11 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _is_integer(n):
+def _is_integer(n) -> bool:
     return np.isclose(n, np.round(n))
 
 
-def _is_swaplike(gate: cirq.Gate):
+def _is_swaplike(gate: cirq.Gate) -> bool:
     if isinstance(gate, ops.SwapPowGate):
         return gate.exponent == 1