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

cirq/transformers/analytical_decompositions/two_qubit_state_preparation.py

@@ -14,7 +14,9 @@
 
 """Utility methods for efficiently preparing two qubit states."""
 
-from typing import List, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -38,12 +40,8 @@ def _1q_matrices_to_ops(g0, g1, q0, q1, include_identity=False):
 
 
 def prepare_two_qubit_state_using_sqrt_iswap(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
-    state: 'cirq.STATE_VECTOR_LIKE',
-    *,
-    use_sqrt_iswap_inv: bool = True,
-) -> List['cirq.Operation']:
+    q0: cirq.Qid, q1: cirq.Qid, state: cirq.STATE_VECTOR_LIKE, *, use_sqrt_iswap_inv: bool = True
+) -> list[cirq.Operation]:
     """Prepares the given 2q state from |00> using at-most 1 √iSWAP gate + single qubit rotations.
 
     Entangled states are prepared using exactly 1 √iSWAP gate while product states are prepared
@@ -77,8 +75,8 @@ def prepare_two_qubit_state_using_sqrt_iswap(
 
 
 def prepare_two_qubit_state_using_cz(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', state: 'cirq.STATE_VECTOR_LIKE'
-) -> List['cirq.Operation']:
+    q0: cirq.Qid, q1: cirq.Qid, state: cirq.STATE_VECTOR_LIKE
+) -> list[cirq.Operation]:
     """Prepares the given 2q state from |00> using at-most 1 CZ gate + single qubit rotations.
 
     Entangled states are prepared using exactly 1 CZ gate while product states are prepared
@@ -110,8 +108,8 @@ def prepare_two_qubit_state_using_cz(
 
 
 def prepare_two_qubit_state_using_iswap(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', state: 'cirq.STATE_VECTOR_LIKE', use_iswap_inv: bool = False
-) -> List['cirq.Operation']:
+    q0: cirq.Qid, q1: cirq.Qid, state: cirq.STATE_VECTOR_LIKE, use_iswap_inv: bool = False
+) -> list[cirq.Operation]:
     """Prepares the given 2q state from |00> using at-most 1 ISWAP gate + single qubit rotations.
 
     Entangled states are prepared using exactly 1 ISWAP gate while product states are prepared

cirq/transformers/analytical_decompositions/two_qubit_state_preparation_test.py

@@ -14,6 +14,8 @@
 
 """Tests for efficient two qubit state preparation methods."""
 
+from __future__ import annotations
+
 import copy
 
 import numpy as np

cirq/transformers/analytical_decompositions/two_qubit_to_cz.py

@@ -14,7 +14,9 @@
 
 """Utility methods for decomposing two-qubit unitaries into CZ gates."""
 
-from typing import cast, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import cast, Iterable, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -24,15 +26,14 @@ from cirq.linalg.decompositions import extract_right_diag, num_cnots_required
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions
 from cirq.transformers.eject_phased_paulis import eject_phased_paulis
 from cirq.transformers.eject_z import eject_z
-from cirq.transformers.merge_single_qubit_gates import merge_single_qubit_gates_to_phased_x_and_z
 
 if TYPE_CHECKING:
     import cirq
 
 
 def _remove_partial_czs_or_fail(
-    operations: Iterable['cirq.Operation'], atol: float
-) -> List['cirq.Operation']:
+    operations: Iterable[cirq.Operation], atol: float
+) -> list[cirq.Operation]:
     result = []
     for op in operations:
         if isinstance(op.gate, ops.CZPowGate):
@@ -49,13 +50,13 @@ def _remove_partial_czs_or_fail(
 
 
 def two_qubit_matrix_to_cz_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     mat: np.ndarray,
     allow_partial_czs: bool,
     atol: float = 1e-8,
     clean_operations: bool = True,
-) -> List[ops.Operation]:
+) -> list[ops.Operation]:
     """Decomposes a two-qubit operation into Z/XY/CZ gates.
 
     Args:
@@ -79,19 +80,19 @@ def two_qubit_matrix_to_cz_operations(
     if clean_operations:
         if not allow_partial_czs:
             # CZ^t is not allowed for any $t$ except $t=1$.
-            return _remove_partial_czs_or_fail(cleanup_operations(operations), atol=atol)
-        return cleanup_operations(operations)
+            return _remove_partial_czs_or_fail(cleanup_operations(operations, atol=atol), atol=atol)
+        return cleanup_operations(operations, atol=atol)
     return operations
 
 
 def two_qubit_matrix_to_diagonal_and_cz_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     mat: np.ndarray,
     allow_partial_czs: bool = False,
     atol: float = 1e-8,
     clean_operations: bool = True,
-) -> Tuple[np.ndarray, List['cirq.Operation']]:
+) -> tuple[np.ndarray, list[cirq.Operation]]:
     """Decomposes a 2-qubit unitary to a diagonal and the remaining operations.
 
     For a 2-qubit unitary V, return ops, a list of operations and
@@ -136,7 +137,7 @@ def two_qubit_matrix_to_diagonal_and_cz_operations(
     )
 
 
-def _xx_interaction_via_full_czs(q0: 'cirq.Qid', q1: 'cirq.Qid', x: float):
+def _xx_interaction_via_full_czs(q0: cirq.Qid, q1: cirq.Qid, x: float):
     a = x * -2 / np.pi
     yield ops.H(q1)
     yield ops.CZ(q0, q1)
@@ -145,7 +146,7 @@ def _xx_interaction_via_full_czs(q0: 'cirq.Qid', q1: 'cirq.Qid', x: float):
     yield ops.H(q1)
 
 
-def _xx_yy_interaction_via_full_czs(q0: 'cirq.Qid', q1: 'cirq.Qid', x: float, y: float):
+def _xx_yy_interaction_via_full_czs(q0: cirq.Qid, q1: cirq.Qid, x: float, y: float):
     a = x * -2 / np.pi
     b = y * -2 / np.pi
     yield ops.X(q0) ** 0.5
@@ -160,9 +161,7 @@ def _xx_yy_interaction_via_full_czs(q0: 'cirq.Qid', q1: 'cirq.Qid', x: float, y:
     yield ops.X(q0) ** -0.5
 
 
-def _xx_yy_zz_interaction_via_full_czs(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', x: float, y: float, z: float
-):
+def _xx_yy_zz_interaction_via_full_czs(q0: cirq.Qid, q1: cirq.Qid, x: float, y: float, z: float):
     a = x * -2 / np.pi + 0.5
     b = y * -2 / np.pi + 0.5
     c = z * -2 / np.pi + 0.5
@@ -182,22 +181,87 @@ def _xx_yy_zz_interaction_via_full_czs(
     yield ops.H(q1)
 
 
-def cleanup_operations(operations: Sequence[ops.Operation]):
+def cleanup_operations(operations: Sequence[ops.Operation], atol: float = 1e-8):
+    operations = _merge_single_qubit_gates(operations, atol=atol)
     circuit = circuits.Circuit(operations)
-    circuit = merge_single_qubit_gates_to_phased_x_and_z(circuit)
     circuit = eject_phased_paulis(circuit)
     circuit = eject_z(circuit)
     circuit = circuits.Circuit(circuit.all_operations(), strategy=circuits.InsertStrategy.EARLIEST)
     return list(circuit.all_operations())
 
 
+def _transform_single_qubit_operations_to_phased_x_and_z(
+    operations: Sequence[ops.Operation], atol: float
+) -> Sequence[ops.Operation]:
+    """Transforms operations on the same qubit to a PhasedXPowGate followed by a Z gate.
+
+    Args:
+        operations: sequence of operations on the same qubit
+        atol: a limit on the amount of absolute error introduced by the
+            transformation.
+    Returns:
+        A PhasedXPowGate followed by a Z gate. If one the gates is not needed, it will be omitted.
+    """
+    u = np.eye(2)
+    for op in operations:
+        u = protocols.unitary(op) @ u
+    return [
+        g(op.qubits[0])
+        for g in single_qubit_decompositions.single_qubit_matrix_to_phased_x_z(u, atol=atol)
+    ]
+
+
+def _merge_single_qubit_gates(
+    operations: Sequence[ops.Operation], atol: float
+) -> Sequence[ops.Operation]:
+    """Merge consecutive single qubit gates.
+
+    Traverses the sequence of operations maintaining a list of consecutive single qubit
+    operations for each qubit. When a 2-qubit gate is encountered, it transforms pending
+    operations to a PhasedXPowGate followed by a Z gate.
+
+    Args:
+        operations: sequence of operations
+        atol: a limit on the amount of absolute error introduced by the
+            transformation.
+    Returns:
+        new sequence of operations after merging gates
+
+    Raises:
+        ValueError: if one of the operations is not on 1 or 2 qubits
+    """
+    merged_ops: list[ops.Operation] = []
+    pending_ops: dict[tuple[cirq.Qid, ...], list[ops.Operation]] = dict()
+    for op in operations:
+        if protocols.num_qubits(op) == 2:
+            for qubit_ops in pending_ops.values():
+                merged_ops.extend(
+                    _transform_single_qubit_operations_to_phased_x_and_z(qubit_ops, atol=atol)
+                )
+            pending_ops.clear()
+            # Add the 2-qubit gate
+            merged_ops.append(op)
+        elif protocols.num_qubits(op) == 1:
+            if op.qubits not in pending_ops:
+                pending_ops[op.qubits] = []
+            pending_ops[op.qubits].append(op)
+        else:
+            raise ValueError(f'operation is on {protocols.num_qubits(op)} qubits, expected 1 or 2')
+    # Merge remaining pending operations
+    for qubit_ops in pending_ops.values():
+        merged_ops.extend(
+            _transform_single_qubit_operations_to_phased_x_and_z(qubit_ops, atol=atol)
+        )
+    return merged_ops
+
+
 def _kak_decomposition_to_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     kak: linalg.KakDecomposition,
     allow_partial_czs: bool,
     atol: float = 1e-8,
-) -> List[ops.Operation]:
+) -> list[ops.Operation]:
     """Assumes that the decomposition is canonical."""
     b0, b1 = kak.single_qubit_operations_before
     pre = [_do_single_on(b0, q0, atol=atol), _do_single_on(b1, q1, atol=atol)]
@@ -232,7 +296,7 @@ def _is_trivial_angle(rad: float, atol: float) -> bool:
 
 
 def _parity_interaction(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', rads: float, atol: float, gate: Optional[ops.Gate] = None
+    q0: cirq.Qid, q1: cirq.Qid, rads: float, atol: float, gate: ops.Gate | None = None
 ):
     """Yields a ZZ interaction framed by the given operation."""
     if abs(rads) < atol:
@@ -255,15 +319,15 @@ def _parity_interaction(
         yield g.on(q0), g.on(q1)
 
 
-def _do_single_on(u: np.ndarray, q: 'cirq.Qid', atol: float = 1e-8):
+def _do_single_on(u: np.ndarray, q: cirq.Qid, atol: float = 1e-8):
     for gate in single_qubit_decompositions.single_qubit_matrix_to_gates(u, atol):
         yield gate(q)
 
 
 def _non_local_part(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
-    interaction_coefficients: Tuple[float, float, float],
+    q0: cirq.Qid,
+    q1: cirq.Qid,
+    interaction_coefficients: tuple[float, float, float],
     allow_partial_czs: bool,
     atol: float = 1e-8,
 ):

cirq/transformers/analytical_decompositions/two_qubit_to_cz_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cmath
 import random
 
@@ -24,6 +26,7 @@ from cirq.testing import random_two_qubit_circuit_with_czs
 from cirq.transformers.analytical_decompositions.two_qubit_to_cz import (
     _is_trivial_angle,
     _parity_interaction,
+    cleanup_operations,
     two_qubit_matrix_to_diagonal_and_cz_operations,
 )
 
@@ -52,7 +55,7 @@ from cirq.transformers.analytical_decompositions.two_qubit_to_cz import (
         ]
     )(1e-8 * 2 / 3, 1e-8 * 4 / 3),
 )
-def test_is_trivial_angle(rad, expected):
+def test_is_trivial_angle(rad, expected) -> None:
     tolerance = 1e-8
     out = _is_trivial_angle(rad, tolerance)
     assert out == expected, f'rad = {rad}'
@@ -149,7 +152,7 @@ def assert_ops_implement_unitary(q0, q1, operations, intended_effect, atol=0.01)
 )
 def test_two_to_ops_equivalent_and_bounded_for_known_and_random(
     max_partial_cz_depth, max_full_cz_depth, effect
-):
+) -> None:
     q0 = cirq.NamedQubit('q0')
     q1 = cirq.NamedQubit('q1')
 
@@ -163,7 +166,7 @@ def test_two_to_ops_equivalent_and_bounded_for_known_and_random(
     assert_cz_depth_below(operations_with_full, max_full_cz_depth, True)
 
 
-def test_trivial_parity_interaction_corner_case():
+def test_trivial_parity_interaction_corner_case() -> None:
     q0 = cirq.NamedQubit('q0')
     q1 = cirq.NamedQubit('q1')
     nearPi4 = np.pi / 4 * 0.99
@@ -172,7 +175,7 @@ def test_trivial_parity_interaction_corner_case():
     assert len(circuit) == 2
 
 
-def test_kak_decomposition_depth_full_cz():
+def test_kak_decomposition_depth_full_cz() -> None:
     a, b = cirq.LineQubit.range(2)
 
     # Random.
@@ -210,7 +213,7 @@ def test_kak_decomposition_depth_full_cz():
     assert len(c) <= 4
 
 
-def test_kak_decomposition_depth_partial_cz():
+def test_kak_decomposition_depth_partial_cz() -> None:
     a, b = cirq.LineQubit.range(2)
 
     # Random.
@@ -250,7 +253,7 @@ def test_kak_decomposition_depth_partial_cz():
         np.diag(np.exp(1j * np.pi * np.random.random(4))),
     ],
 )
-def test_decompose_to_diagonal_and_circuit(v):
+def test_decompose_to_diagonal_and_circuit(v) -> None:
     b, c = cirq.LineQubit.range(2)
     diagonal, ops = two_qubit_matrix_to_diagonal_and_cz_operations(b, c, v, atol=1e-8)
     assert cirq.is_diagonal(diagonal)
@@ -259,7 +262,25 @@ def test_decompose_to_diagonal_and_circuit(v):
     cirq.testing.assert_allclose_up_to_global_phase(circuit_unitary, v, atol=2e-6)
 
 
-def test_remove_partial_czs_or_fail():
+@pytest.mark.parametrize(
+    "mat, num_czs",
+    [
+        (cirq.unitary(random_two_qubit_circuit_with_czs(3)), 2),
+        (cirq.unitary(random_two_qubit_circuit_with_czs(2)), 2),
+        (cirq.unitary(random_two_qubit_circuit_with_czs(1)), 1),
+        (cirq.unitary(random_two_qubit_circuit_with_czs(0)), 0),
+    ],
+)
+def test_decompose_to_diagonal_and_circuit_returns_circuit_with_expected_number_of_czs(
+    mat, num_czs
+):
+    b, c = cirq.LineQubit.range(2)
+    _, ops = two_qubit_matrix_to_diagonal_and_cz_operations(b, c, mat, atol=1e-8)
+    circuit = cirq.Circuit(ops)
+    assert len(list(circuit.findall_operations_with_gate_type(cirq.CZPowGate))) == num_czs
+
+
+def test_remove_partial_czs_or_fail() -> None:
     CZ = cirq.CZ(*cirq.LineQubit.range(2))
     assert (
         cirq.transformers.analytical_decompositions.two_qubit_to_cz._remove_partial_czs_or_fail(
@@ -274,3 +295,11 @@ def test_remove_partial_czs_or_fail():
         _ = cirq.transformers.analytical_decompositions.two_qubit_to_cz._remove_partial_czs_or_fail(
             [CZ**-0.5], atol=1e-9
         )
+
+
+@pytest.mark.parametrize("gate", [cirq.CCZ, cirq.GlobalPhaseGate(1.0)])
+def test_cleanup_operations_raises_if_op_not_on_1_or_2_qubits(gate: cirq.Gate) -> None:
+    qubits = cirq.LineQubit.range(gate.num_qubits())
+    op = gate.on(*qubits)
+    with pytest.raises(ValueError, match="expected 1 or 2"):
+        cleanup_operations([op], atol=1e-8)

cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py

@@ -14,7 +14,9 @@
 
 """Utility methods for decomposing two-qubit unitaries into FSim gates."""
 
-from typing import Iterable, Iterator, List, Optional, Sequence, TYPE_CHECKING, Union
+from __future__ import annotations
+
+from typing import Iterable, Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -25,11 +27,11 @@ if TYPE_CHECKING:
 
 
 def decompose_two_qubit_interaction_into_four_fsim_gates(
-    interaction: Union['cirq.SupportsUnitary', np.ndarray],
+    interaction: cirq.SupportsUnitary | np.ndarray,
     *,
-    fsim_gate: Union['cirq.FSimGate', 'cirq.ISwapPowGate'],
-    qubits: Optional[Sequence['cirq.Qid']] = None,
-) -> 'cirq.Circuit':
+    fsim_gate: cirq.FSimGate | cirq.ISwapPowGate,
+    qubits: Sequence[cirq.Qid] | None = None,
+) -> cirq.Circuit:
     """Decomposes operations into an FSimGate near theta=pi/2, phi=0.
 
     This decomposition is guaranteed to use exactly four of the given FSim
@@ -98,7 +100,7 @@ def decompose_two_qubit_interaction_into_four_fsim_gates(
     return result
 
 
-def _sticky_0_to_1(v: float, *, atol: float) -> Optional[float]:
+def _sticky_0_to_1(v: float, *, atol: float) -> float | None:
     if 0 <= v <= 1:
         return v
     if 1 < v <= 1 + atol:
@@ -110,12 +112,12 @@ def _sticky_0_to_1(v: float, *, atol: float) -> Optional[float]:
 
 def _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
     *,
-    qubits: Sequence['cirq.Qid'],
-    fsim_gate: 'cirq.FSimGate',
+    qubits: Sequence[cirq.Qid],
+    fsim_gate: cirq.FSimGate,
     canonical_x_kak_coefficient: float,
     canonical_y_kak_coefficient: float,
     atol: float = 1e-8,
-) -> List['cirq.Operation']:
+) -> list[cirq.Operation]:
     x = canonical_x_kak_coefficient
     y = canonical_y_kak_coefficient
     assert 0 <= y <= x <= np.pi / 4
@@ -174,10 +176,10 @@ _B = _BGate()
 
 
 def _decompose_two_qubit_interaction_into_two_b_gates(
-    interaction: Union['cirq.SupportsUnitary', np.ndarray, 'cirq.KakDecomposition'],
+    interaction: cirq.SupportsUnitary | np.ndarray | cirq.KakDecomposition,
     *,
-    qubits: Sequence['cirq.Qid'],
-) -> List['cirq.Operation']:
+    qubits: Sequence[cirq.Qid],
+) -> list[cirq.Operation]:
     kak = linalg.kak_decomposition(interaction)
 
     result = _decompose_interaction_into_two_b_gates_ignoring_single_qubit_ops(
@@ -192,8 +194,8 @@ def _decompose_two_qubit_interaction_into_two_b_gates(
 
 
 def _decompose_b_gate_into_two_fsims(
-    *, fsim_gate: 'cirq.FSimGate', qubits: Sequence['cirq.Qid']
-) -> List['cirq.Operation']:
+    *, fsim_gate: cirq.FSimGate, qubits: Sequence[cirq.Qid]
+) -> list[cirq.Operation]:
     kak = linalg.kak_decomposition(_B)
 
     result = _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
@@ -211,8 +213,8 @@ def _decompose_b_gate_into_two_fsims(
 
 
 def _decompose_interaction_into_two_b_gates_ignoring_single_qubit_ops(
-    qubits: Sequence['cirq.Qid'], kak_interaction_coefficients: Iterable[float]
-) -> List['cirq.Operation']:
+    qubits: Sequence[cirq.Qid], kak_interaction_coefficients: Iterable[float]
+) -> list[cirq.Operation]:
     """Decompose using a minimal construction of two-qubit operations.
 
     References:
@@ -236,11 +238,8 @@ def _decompose_interaction_into_two_b_gates_ignoring_single_qubit_ops(
 
 
 def _fix_single_qubit_gates_around_kak_interaction(
-    *,
-    desired: 'cirq.KakDecomposition',
-    operations: List['cirq.Operation'],
-    qubits: Sequence['cirq.Qid'],
-) -> Iterator['cirq.Operation']:
+    *, desired: cirq.KakDecomposition, operations: list[cirq.Operation], qubits: Sequence[cirq.Qid]
+) -> Iterator[cirq.Operation]:
     """Adds single qubit operations to complete a desired interaction.
 
     Args:

cirq/transformers/analytical_decompositions/two_qubit_to_fsim_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 import random
 from typing import Any
@@ -65,7 +67,7 @@ FEASIBLE_FSIM_GATES = [
 
 
 @pytest.mark.parametrize('obj', UNITARY_OBJS)
-def test_decompose_two_qubit_interaction_into_two_b_gates(obj: Any):
+def test_decompose_two_qubit_interaction_into_two_b_gates(obj: Any) -> None:
     circuit = cirq.Circuit(
         _decompose_two_qubit_interaction_into_two_b_gates(obj, qubits=cirq.LineQubit.range(2))
     )
@@ -75,7 +77,7 @@ def test_decompose_two_qubit_interaction_into_two_b_gates(obj: Any):
     np.testing.assert_allclose(cirq.unitary(circuit), desired_unitary, atol=1e-6)
 
 
-def test_decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops_fail():
+def test_decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops_fail() -> None:
     c = _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
         qubits=cirq.LineQubit.range(2),
         fsim_gate=cirq.FSimGate(theta=np.pi / 2, phi=0),
@@ -98,7 +100,7 @@ def test_decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops_fail():
 @pytest.mark.parametrize('obj,fsim_gate', itertools.product(UNITARY_OBJS, FEASIBLE_FSIM_GATES))
 def test_decompose_two_qubit_interaction_into_four_fsim_gates_equivalence(
     obj: Any, fsim_gate: cirq.FSimGate
-):
+) -> None:
     qubits = obj.qubits if isinstance(obj, cirq.Operation) else cirq.LineQubit.range(2)
     circuit = cirq.decompose_two_qubit_interaction_into_four_fsim_gates(obj, fsim_gate=fsim_gate)
     desired_unitary = obj if isinstance(obj, np.ndarray) else cirq.unitary(obj)
@@ -108,7 +110,7 @@ def test_decompose_two_qubit_interaction_into_four_fsim_gates_equivalence(
     assert cirq.approx_eq(circuit.unitary(qubit_order=qubits), desired_unitary, atol=1e-4)
 
 
-def test_decompose_two_qubit_interaction_into_four_fsim_gates_validate():
+def test_decompose_two_qubit_interaction_into_four_fsim_gates_validate() -> None:
     iswap = cirq.FSimGate(theta=np.pi / 2, phi=0)
     with pytest.raises(ValueError, match='fsim_gate.theta'):
         cirq.decompose_two_qubit_interaction_into_four_fsim_gates(
@@ -127,7 +129,7 @@ def test_decompose_two_qubit_interaction_into_four_fsim_gates_validate():
         cirq.decompose_two_qubit_interaction_into_four_fsim_gates(np.eye(4), fsim_gate=fsim)
 
 
-def test_decompose_two_qubit_interaction_into_four_fsim_gates():
+def test_decompose_two_qubit_interaction_into_four_fsim_gates() -> None:
     iswap = cirq.FSimGate(theta=np.pi / 2, phi=0)
 
     # Defaults to line qubits.
@@ -153,7 +155,7 @@ def test_decompose_two_qubit_interaction_into_four_fsim_gates():
     assert set(c.all_qubits()) == set(cirq.LineQubit.range(10, 12))
 
 
-def test_sticky_0_to_1():
+def test_sticky_0_to_1() -> None:
     assert _sticky_0_to_1(-1, atol=1e-8) is None
 
     assert _sticky_0_to_1(-1e-6, atol=1e-8) is None

cirq/transformers/analytical_decompositions/two_qubit_to_ms.py

@@ -19,24 +19,22 @@ Gate compilation methods implemented here are following the paper below:
     arXiv:1603.07678
 """
 
-from typing import cast, Iterable, List, Optional, Tuple, TYPE_CHECKING
+from __future__ import annotations
 
-import numpy as np
+from typing import cast, Iterable, TYPE_CHECKING
 
 from cirq import linalg, ops, protocols
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions, two_qubit_to_cz
 
 if TYPE_CHECKING:
+    import numpy as np
+
     import cirq
 
 
 def two_qubit_matrix_to_ion_operations(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
-    mat: np.ndarray,
-    atol: float = 1e-8,
-    clean_operations: bool = True,
-) -> List[ops.Operation]:
+    q0: cirq.Qid, q1: cirq.Qid, mat: np.ndarray, atol: float = 1e-8, clean_operations: bool = True
+) -> list[ops.Operation]:
     """Decomposes a two-qubit operation into MS/single-qubit rotation gates.
 
     Args:
@@ -56,8 +54,8 @@ def two_qubit_matrix_to_ion_operations(
 
 
 def _kak_decomposition_to_operations(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', kak: linalg.KakDecomposition, atol: float = 1e-8
-) -> List[ops.Operation]:
+    q0: cirq.Qid, q1: cirq.Qid, kak: linalg.KakDecomposition, atol: float = 1e-8
+) -> list[ops.Operation]:
     """Assumes that the decomposition is canonical."""
     b0, b1 = kak.single_qubit_operations_before
     pre = [_do_single_on(b0, q0, atol), _do_single_on(b1, q1, atol)]
@@ -74,13 +72,13 @@ def _kak_decomposition_to_operations(
     )
 
 
-def _do_single_on(u: np.ndarray, q: 'cirq.Qid', atol: float = 1e-8):
+def _do_single_on(u: np.ndarray, q: cirq.Qid, atol: float = 1e-8):
     for gate in single_qubit_decompositions.single_qubit_matrix_to_gates(u, atol):
         yield gate(q)
 
 
 def _parity_interaction(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', rads: float, atol: float, gate: Optional[ops.Gate] = None
+    q0: cirq.Qid, q1: cirq.Qid, rads: float, atol: float, gate: ops.Gate | None = None
 ):
     """Yields an XX interaction framed by the given operation."""
 
@@ -98,9 +96,9 @@ def _parity_interaction(
 
 
 def _non_local_part(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
-    interaction_coefficients: Tuple[float, float, float],
+    q0: cirq.Qid,
+    q1: cirq.Qid,
+    interaction_coefficients: tuple[float, float, float],
     atol: float = 1e-8,
 ):
     """Yields non-local operation of KAK decomposition."""

cirq/transformers/analytical_decompositions/two_qubit_to_ms_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import random
 
 import numpy as np
@@ -130,7 +132,7 @@ def assert_ms_depth_below(operations, threshold):
     (2, _random_double_MS_effect()) for _ in range(10)
 ])
 # yapf: enable
-def test_two_to_ops(max_ms_depth: int, effect: np.ndarray):
+def test_two_to_ops(max_ms_depth: int, effect: np.ndarray) -> None:
     q0 = cirq.NamedQubit('q0')
     q1 = cirq.NamedQubit('q1')