cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/transformers/analytical_decompositions/quantum_shannon_decomposition.py

@@ -19,30 +19,46 @@ Based on:
 Synthesis of Quantum Logic Circuits. Tech. rep. 2006,
 https://arxiv.org/abs/quant-ph/0406176
 """
-from typing import List, Callable, TYPE_CHECKING
-
-from scipy.linalg import cossin
+from typing import Callable, Iterable, List, TYPE_CHECKING
 
 import numpy as np
+from scipy.linalg import cossin
 
 from cirq import ops
+from cirq.circuits.frozen_circuit import FrozenCircuit
 from cirq.linalg import decompositions, predicates
+from cirq.protocols import unitary_protocol
+from cirq.transformers.analytical_decompositions.three_qubit_decomposition import (
+    three_qubit_matrix_to_operations,
+)
+from cirq.transformers.analytical_decompositions.two_qubit_to_cz import (
+    two_qubit_matrix_to_cz_operations,
+)
 
 if TYPE_CHECKING:
     import cirq
-    from cirq.ops import op_tree
 
 
-def quantum_shannon_decomposition(qubits: 'List[cirq.Qid]', u: np.ndarray) -> 'op_tree.OpTree':
-    """Decomposes n-qubit unitary into CX/YPow/ZPow/CNOT gates, preserving global phase.
+def quantum_shannon_decomposition(
+    qubits: 'List[cirq.Qid]', u: np.ndarray, atol: float = 1e-8
+) -> Iterable['cirq.Operation']:
+    """Decomposes n-qubit unitary 1-q, 2-q and GlobalPhase gates, preserving global phase.
+
+    The gates used are CX/YPow/ZPow/CNOT/GlobalPhase/CZ/PhasedXZGate/PhasedXPowGate.
 
     The algorithm is described in Shende et al.:
     Synthesis of Quantum Logic Circuits. Tech. rep. 2006,
     https://arxiv.org/abs/quant-ph/0406176
 
+    Note: Shannon decomposition is sensitive to the numerical accuracy of doing eigendecomposition.
+        Eigendecomposition is obtained using `np.linalg.eig` and the resulting difference between
+        the input and output unitary is heavily affected by the accuracy of `np.linalg.eig`.
+
+
     Args:
         qubits: List of qubits in order of significance
         u: Numpy array for unitary matrix representing gate to be decomposed
+        atol: Absolute tolerance of floating point checks.
 
     Calls:
         (Base Case)
@@ -62,7 +78,7 @@ def quantum_shannon_decomposition(qubits: 'List[cirq.Qid]', u: np.ndarray) -> 'o
         ValueError: If the u matrix is non-unitary
         ValueError: If the u matrix is not of shape (2^n,2^n)
     """
-    if not predicates.is_unitary(u):  # Check that u is unitary
+    if not predicates.is_unitary(u, atol=atol):  # Check that u is unitary
         raise ValueError(
             "Expected input matrix u to be unitary, \
                 but it fails cirq.is_unitary check"
@@ -80,6 +96,32 @@ def quantum_shannon_decomposition(qubits: 'List[cirq.Qid]', u: np.ndarray) -> 'o
         yield from _single_qubit_decomposition(qubits[0], u)
         return
 
+    if n == 4:
+        operations = tuple(
+            two_qubit_matrix_to_cz_operations(
+                qubits[0], qubits[1], u, allow_partial_czs=True, clean_operations=True, atol=atol
+            )
+        )
+        yield from operations
+        i, j = np.unravel_index(np.argmax(np.abs(u)), u.shape)
+        new_unitary = unitary_protocol.unitary(FrozenCircuit.from_moments(*operations))
+        global_phase = np.angle(u[i, j]) - np.angle(new_unitary[i, j])
+        if np.abs(global_phase) > 1e-9:
+            yield ops.global_phase_operation(np.exp(1j * global_phase))
+        return
+
+    if n == 8:
+        operations = tuple(
+            three_qubit_matrix_to_operations(qubits[0], qubits[1], qubits[2], u, atol=atol)
+        )
+        yield from operations
+        i, j = np.unravel_index(np.argmax(np.abs(u)), u.shape)
+        new_unitary = unitary_protocol.unitary(FrozenCircuit.from_moments(*operations))
+        global_phase = np.angle(u[i, j]) - np.angle(new_unitary[i, j])
+        if np.abs(global_phase) > 1e-9:
+            yield ops.global_phase_operation(np.exp(1j * global_phase))
+        return
+
     # Perform a cosine-sine (linalg) decomposition on u
     #   X   =   [ u1 , 0  ] [ cos(theta) , -sin(theta) ] [ v1 , 0  ]
     #           [ 0  , u2 ] [ sin(theta) ,  cos(theta) ] [ 0  , v2 ]
@@ -97,7 +139,7 @@ def quantum_shannon_decomposition(qubits: 'List[cirq.Qid]', u: np.ndarray) -> 'o
     yield from _msb_demuxer(qubits, u1, u2)
 
 
-def _single_qubit_decomposition(qubit: 'cirq.Qid', u: np.ndarray) -> 'op_tree.OpTree':
+def _single_qubit_decomposition(qubit: 'cirq.Qid', u: np.ndarray) -> Iterable['cirq.Operation']:
     """Decomposes single-qubit gate, and returns list of operations, keeping phase invariant.
 
     Args:
@@ -108,22 +150,41 @@ def _single_qubit_decomposition(qubit: 'cirq.Qid', u: np.ndarray) -> 'op_tree.Op
         A single operation from OP TREE of 3 operations (rz,ry,ZPowGate)
     """
     # Perform native ZYZ decomposition
-    phi_0, phi_1, phi_2 = decompositions.deconstruct_single_qubit_matrix_into_angles(u)
+    phi_0, phi_1, phi_2 = np.array(
+        decompositions.deconstruct_single_qubit_matrix_into_angles(u)
+    ) % (2 * np.pi)
 
     # Determine global phase picked up
-    phase = np.angle(u[0, 0] / (np.exp(-1j * (phi_0) / 2) * np.cos(phi_1 / 2)))
-
-    # Append first two operations operations
-    yield ops.rz(phi_0).on(qubit)
-    yield ops.ry(phi_1).on(qubit)
-
-    # Append third operation with global phase added
-    yield ops.ZPowGate(exponent=phi_2 / np.pi, global_shift=phase / phi_2).on(qubit)
+    global_phase = np.angle(u[0, 0]) + phi_0 / 2 + phi_2 / 2
+    if np.abs(u[0, 0]) < 1e-9:
+        global_phase = np.angle(u[1, 0]) + phi_0 / 2 - phi_2 / 2
+
+    if np.abs(phi_2) > 1e-18:
+        # Append first two operations operations
+        yield ops.rz(phi_0).on(qubit)
+        yield ops.ry(phi_1).on(qubit)
+
+        # Append third operation with global phase added
+        yield ops.ZPowGate(exponent=phi_2 / np.pi, global_shift=global_phase / phi_2 - 0.5)(qubit)
+    elif np.abs(phi_1) > 1e-18:
+        # Just a Z -> Y rotation so we attach the global phase to the Y rotation.
+        if np.abs(phi_0) > 1e-18:
+            yield ops.rz(phi_0)(qubit)
+        yield ops.YPowGate(exponent=phi_1 / np.pi, global_shift=global_phase / phi_1 - 0.5)(qubit)
+    elif np.abs(phi_0) > 1e-18:
+        # Just an Rz with a potential global phase.
+        yield ops.ZPowGate(exponent=phi_0 / np.pi, global_shift=global_phase / phi_0 - 0.5)(qubit)
+    elif np.abs(global_phase) > 1e-18:
+        # Global Phase.
+        yield ops.global_phase_operation(np.exp(1j * global_phase))
+    else:
+        # Identity.
+        return
 
 
 def _msb_demuxer(
     demux_qubits: 'List[cirq.Qid]', u1: np.ndarray, u2: np.ndarray
-) -> 'op_tree.OpTree':
+) -> Iterable['cirq.Operation']:
     """Demultiplexes a unitary matrix that is multiplexed in its most-significant-qubit.
 
     Decomposition structure:
@@ -146,8 +207,21 @@ def _msb_demuxer(
     Yields: Single operation from OP TREE of 2-qubit and 1-qubit operations
     """
     # Perform a diagonalization to find values
+    u1 = u1.astype(np.complex128)
+    u2 = u2.astype(np.complex128)
     u = u1 @ u2.T.conjugate()
-    dsquared, V = np.linalg.eig(u)
+    if predicates.is_hermitian(u):
+        # If `u` is hermitian, use the more accurate `eigh` method.
+        dsquared, V = np.linalg.eigh(u)
+    else:
+        dsquared, V = np.linalg.eig(u)
+        # Use Gram–Schmidt to obtain orthonormal eigenvectors for each of the subspaces.
+        for i in range(V.shape[0]):
+            for j in range(i):
+                if np.abs(dsquared[i] - dsquared[j]) < 1e-9:
+                    V[:, i] -= np.dot(V[:, j].conj(), V[:, i]) * V[:, j]
+            V[:, i] /= np.linalg.norm(V[:, i])  # normalize.
+    dsquared = dsquared.astype(np.complex128)
     d = np.sqrt(dsquared)
     D = np.diag(d)
     W = D @ V.T.conjugate() @ u2
@@ -155,7 +229,7 @@ def _msb_demuxer(
     # Last term is given by ( I ⊗ W ), demultiplexed
     # Remove most-significant (demuxed) control-qubit
     # Yield operations for QSD on W
-    yield from quantum_shannon_decomposition(demux_qubits[1:], W)
+    yield from quantum_shannon_decomposition(demux_qubits[1:], W, atol=1e-6)
 
     # Use complex phase of d_i to give theta_i (so d_i* gives -theta_i)
     # Observe that middle part looks like Σ_i( Rz(theta_i)⊗|i><i| )
@@ -163,7 +237,7 @@ def _msb_demuxer(
     yield from _multiplexed_cossin(demux_qubits, -np.angle(d), ops.rz)
 
     # Yield operations for QSD on V
-    yield from quantum_shannon_decomposition(demux_qubits[1:], V)
+    yield from quantum_shannon_decomposition(demux_qubits[1:], V, atol=1e-6)
 
 
 def _nth_gray(n: int) -> int:
@@ -173,7 +247,7 @@ def _nth_gray(n: int) -> int:
 
 def _multiplexed_cossin(
     cossin_qubits: 'List[cirq.Qid]', angles: List[float], rot_func: Callable = ops.ry
-) -> 'op_tree.OpTree':
+) -> Iterable['cirq.Operation']:
     """Performs a multiplexed rotation over all qubits in this unitary matrix,
 
     Uses ry and rz multiplexing for quantum shannon decomposition
@@ -223,8 +297,9 @@ def _multiplexed_cossin(
         #   so introduce max function
         select_qubit = max(-select_qubit - 1, -len(control_qubits))
 
-        # Add a rotation on the main qubit
-        yield rot_func(rotation).on(main_qubit)
+        if np.abs(rotation) > 1e-9:
+            # Add a rotation on the main qubit
+            yield rot_func(rotation).on(main_qubit)
 
         # Add a CNOT from the select qubit to the main qubit
         yield ops.CNOT(control_qubits[select_qubit], main_qubit)

cirq/transformers/analytical_decompositions/quantum_shannon_decomposition_test.py

@@ -12,21 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import numpy as np
+import pytest
+from scipy.stats import unitary_group
+
 import cirq
 from cirq.ops import common_gates
 from cirq.transformers.analytical_decompositions.quantum_shannon_decomposition import (
+    _msb_demuxer,
     _multiplexed_cossin,
     _nth_gray,
-    _msb_demuxer,
     _single_qubit_decomposition,
     quantum_shannon_decomposition,
 )
 
-import pytest
-import numpy as np
-from scipy.stats import unitary_group
-
 
+@pytest.mark.xfail(reason='#6765')
 @pytest.mark.parametrize('n_qubits', list(range(1, 8)))
 def test_random_qsd_n_qubit(n_qubits):
     U = unitary_group.rvs(2**n_qubits)
@@ -34,9 +35,8 @@ def test_random_qsd_n_qubit(n_qubits):
     circuit = cirq.Circuit(quantum_shannon_decomposition(qubits, U))
     # Test return is equal to inital unitary
     assert cirq.approx_eq(U, circuit.unitary(), atol=1e-9)
-    # Test all operations in gate set
-    gates = (common_gates.Rz, common_gates.Ry, common_gates.ZPowGate, common_gates.CXPowGate)
-    assert all(isinstance(op.gate, gates) for op in circuit.all_operations())
+    # Test all operations have at most 2 qubits.
+    assert all(cirq.num_qubits(op) <= 2 for op in circuit.all_operations())
 
 
 def test_qsd_n_qubit_errors():
@@ -53,9 +53,8 @@ def test_random_single_qubit_decomposition():
     circuit = cirq.Circuit(_single_qubit_decomposition(qubit, U))
     # Test return is equal to inital unitary
     assert cirq.approx_eq(U, circuit.unitary(), atol=1e-9)
-    # Test all operations in gate set
-    gates = (common_gates.Rz, common_gates.Ry, common_gates.ZPowGate, common_gates.CXPowGate)
-    assert all(isinstance(op.gate, gates) for op in circuit.all_operations())
+    # Test all operations have at most 2 qubits.
+    assert all(cirq.num_qubits(op) <= 2 for op in circuit.all_operations())
 
 
 def test_msb_demuxer():
@@ -66,9 +65,8 @@ def test_msb_demuxer():
     circuit = cirq.Circuit(_msb_demuxer(qubits, U1, U2))
     # Test return is equal to inital unitary
     assert cirq.approx_eq(U_full, circuit.unitary(), atol=1e-9)
-    # Test all operations in gate set
-    gates = (common_gates.Rz, common_gates.Ry, common_gates.ZPowGate, common_gates.CXPowGate)
-    assert all(isinstance(op.gate, gates) for op in circuit.all_operations())
+    # Test all operations have at most 2 qubits.
+    assert all(cirq.num_qubits(op) <= 2 for op in circuit.all_operations())
 
 
 def test_multiplexed_cossin():
@@ -110,3 +108,96 @@ def test_multiplexed_cossin():
 )
 def test_nth_gray(n, gray):
     assert _nth_gray(n) == gray
+
+
+def test_ghz_circuit_decomposes():
+    # Test case from #6725
+    ghz_circuit = cirq.Circuit(cirq.H(cirq.q(0)), cirq.CNOT(cirq.q(0), cirq.q(1)))
+    ghz_unitary = cirq.unitary(ghz_circuit)
+    decomposed_circuit = cirq.Circuit(
+        quantum_shannon_decomposition(cirq.LineQubit.range(2), ghz_unitary)
+    )
+    new_unitary = cirq.unitary(decomposed_circuit)
+    np.testing.assert_allclose(new_unitary, ghz_unitary, atol=1e-6)
+
+
+def test_qft_decomposes():
+    # Test case from #6666
+    qs = cirq.LineQubit.range(4)
+    qft_circuit = cirq.Circuit(cirq.qft(*qs))
+    qft_unitary = cirq.unitary(qft_circuit)
+    decomposed_circuit = cirq.Circuit(quantum_shannon_decomposition(qs, qft_unitary))
+    new_unitary = cirq.unitary(decomposed_circuit)
+    np.testing.assert_allclose(new_unitary, qft_unitary, atol=1e-6)
+
+
+# Cliffords test the different corner cases of the ZYZ decomposition.
+@pytest.mark.parametrize(
+    ['gate', 'num_ops'],
+    [
+        (cirq.I, 0),
+        (cirq.X, 2),  # rz & ry
+        (cirq.Y, 1),  # ry
+        (cirq.Z, 1),  # rz
+        (cirq.H, 2),  # rz & ry
+        (cirq.S, 1),  # rz & ry
+    ],
+)
+def test_cliffords(gate, num_ops):
+    desired_unitary = cirq.unitary(gate)
+    shannon_circuit = cirq.Circuit(quantum_shannon_decomposition((cirq.q(0),), desired_unitary))
+    new_unitary = cirq.unitary(shannon_circuit)
+    assert len([*shannon_circuit.all_operations()]) == num_ops
+    if num_ops:
+        np.testing.assert_allclose(new_unitary, desired_unitary)
+
+
+@pytest.mark.parametrize('gate', [cirq.X, cirq.Y, cirq.Z, cirq.H, cirq.S])
+def test_cliffords_with_global_phase(gate):
+    global_phase = np.exp(1j * np.random.choice(np.linspace(0.1, 2 * np.pi, 10)))
+    desired_unitary = cirq.unitary(gate) * global_phase
+    shannon_circuit = cirq.Circuit(quantum_shannon_decomposition((cirq.q(0),), desired_unitary))
+    new_unitary = cirq.unitary(shannon_circuit)
+    np.testing.assert_allclose(new_unitary, desired_unitary)
+
+
+def test_global_phase():
+    global_phase = np.exp(1j * np.random.choice(np.linspace(0, 2 * np.pi, 10)))
+    shannon_circuit = cirq.Circuit(
+        quantum_shannon_decomposition((cirq.q(0),), np.eye(2) * global_phase)
+    )
+    new_unitary = cirq.unitary(shannon_circuit)
+    np.testing.assert_allclose(np.diag(new_unitary), global_phase)
+
+
+@pytest.mark.parametrize('gate', [cirq.CZ, cirq.CNOT, cirq.XX, cirq.YY, cirq.ZZ])
+def test_two_qubit_gate(gate):
+    global_phase = np.exp(1j * np.random.choice(np.linspace(0, 2 * np.pi, 10)))
+    desired_unitary = cirq.unitary(gate) * global_phase
+    shannon_circuit = cirq.Circuit(
+        quantum_shannon_decomposition(cirq.LineQubit.range(2), desired_unitary)
+    )
+    new_unitary = cirq.unitary(shannon_circuit)
+    np.testing.assert_allclose(new_unitary, desired_unitary, atol=1e-6)
+
+
+@pytest.mark.parametrize('gate', [cirq.CCNOT, cirq.qft(*cirq.LineQubit.range(3))])
+def test_three_qubit_gate(gate):
+    global_phase = np.exp(1j * np.random.choice(np.linspace(0, 2 * np.pi, 10)))
+    desired_unitary = cirq.unitary(gate) * global_phase
+    shannon_circuit = cirq.Circuit(
+        quantum_shannon_decomposition(cirq.LineQubit.range(3), desired_unitary)
+    )
+    new_unitary = cirq.unitary(shannon_circuit)
+    np.testing.assert_allclose(new_unitary, desired_unitary, atol=1e-6)
+
+
+@pytest.mark.xfail(reason='#6765')
+def test_qft5():
+    global_phase = np.exp(1j * np.random.choice(np.linspace(0, 2 * np.pi, 10)))
+    desired_unitary = cirq.unitary(cirq.qft(*cirq.LineQubit.range(5))) * global_phase
+    shannon_circuit = cirq.Circuit(
+        quantum_shannon_decomposition(cirq.LineQubit.range(5), desired_unitary)
+    )
+    new_unitary = cirq.unitary(shannon_circuit)
+    np.testing.assert_allclose(new_unitary, desired_unitary, atol=1e-6)

cirq/transformers/analytical_decompositions/single_qubit_decompositions.py

@@ -20,7 +20,7 @@ from typing import List, Optional, Tuple
 import numpy as np
 import sympy
 
-from cirq import ops, linalg, protocols
+from cirq import linalg, ops, protocols
 from cirq.linalg.tolerance import near_zero_mod
 
 

cirq/transformers/analytical_decompositions/single_to_two_qubit_isometry.py

@@ -14,10 +14,10 @@
 
 """Analytical decompositions for 2-qubit unitaries when one input qubit is in the |0> state."""
 from typing import List, TYPE_CHECKING
+
 import numpy as np
 
 from cirq import ops
-
 from cirq.transformers.analytical_decompositions import two_qubit_to_cz
 
 if TYPE_CHECKING:

cirq/transformers/analytical_decompositions/single_to_two_qubit_isometry_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 import numpy as np
 import pytest
+
 import cirq
 
 VALID_INITIAL_STATES = [

cirq/transformers/analytical_decompositions/three_qubit_decomposition.py

@@ -14,18 +14,17 @@
 
 """Utility methods for decomposing three-qubit unitaries."""
 
-from typing import Union, Tuple, Sequence, List, Optional
+from typing import List, Optional, Sequence, Tuple, Union
 
 import numpy as np
 
 import cirq
-from cirq import ops
-from cirq import transformers as opt
+from cirq import ops, transformers as opt
 
 
 def three_qubit_matrix_to_operations(
     q0: ops.Qid, q1: ops.Qid, q2: ops.Qid, u: np.ndarray, atol: float = 1e-8
-) -> Sequence[ops.Operation]:
+) -> List[ops.Operation]:
     """Returns operations for a 3 qubit unitary.
 
     The algorithm is described in Shende et al.:

cirq/transformers/analytical_decompositions/three_qubit_decomposition_test.py

@@ -22,9 +22,9 @@ from scipy.linalg import block_diag
 
 import cirq
 from cirq.transformers.analytical_decompositions.three_qubit_decomposition import (
-    _multiplexed_angles,
     _cs_to_ops,
     _middle_multiplexor_to_ops,
+    _multiplexed_angles,
     _two_qubit_multiplexor_to_ops,
 )
 

cirq/transformers/analytical_decompositions/two_qubit_state_preparation.py

@@ -15,9 +15,10 @@
 """Utility methods for efficiently preparing two qubit states."""
 
 from typing import List, TYPE_CHECKING
+
 import numpy as np
 
-from cirq import ops, qis, circuits
+from cirq import circuits, ops, qis
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions
 
 if TYPE_CHECKING:

cirq/transformers/analytical_decompositions/two_qubit_state_preparation_test.py

@@ -16,8 +16,9 @@
 
 import copy
 
-import pytest
 import numpy as np
+import pytest
+
 import cirq
 
 

cirq/transformers/analytical_decompositions/two_qubit_to_cz.py

@@ -14,18 +14,17 @@
 
 """Utility methods for decomposing two-qubit unitaries into CZ gates."""
 
-from typing import Iterable, List, Sequence, Tuple, Optional, cast, TYPE_CHECKING
+from typing import cast, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
 
+from cirq import circuits, linalg, ops, protocols
 from cirq.linalg import predicates
-from cirq.linalg.decompositions import num_cnots_required, extract_right_diag
-
-from cirq import ops, linalg, protocols, circuits
+from cirq.linalg.decompositions import extract_right_diag, num_cnots_required
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions
-from cirq.transformers.merge_single_qubit_gates import merge_single_qubit_gates_to_phased_x_and_z
-from cirq.transformers.eject_z import eject_z
 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

cirq/transformers/analytical_decompositions/two_qubit_to_cz_test.py

@@ -20,12 +20,12 @@ import pytest
 
 import cirq
 from cirq import value
+from cirq.testing import random_two_qubit_circuit_with_czs
 from cirq.transformers.analytical_decompositions.two_qubit_to_cz import (
-    _parity_interaction,
     _is_trivial_angle,
+    _parity_interaction,
     two_qubit_matrix_to_diagonal_and_cz_operations,
 )
-from cirq.testing import random_two_qubit_circuit_with_czs
 
 
 @pytest.mark.parametrize(

cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py

@@ -14,7 +14,7 @@
 
 """Utility methods for decomposing two-qubit unitaries into FSim gates."""
 
-from typing import Sequence, Union, List, Iterator, TYPE_CHECKING, Iterable, Optional
+from typing import Iterable, Iterator, List, Optional, Sequence, TYPE_CHECKING, Union
 
 import numpy as np
 

cirq/transformers/analytical_decompositions/two_qubit_to_fsim_test.py

@@ -22,13 +22,12 @@ import sympy
 
 import cirq
 from cirq.transformers.analytical_decompositions.two_qubit_to_fsim import (
+    _B,
     _decompose_two_qubit_interaction_into_two_b_gates,
     _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops,
     _sticky_0_to_1,
-    _B,
 )
 
-
 UNITARY_OBJS = [
     cirq.IdentityGate(2),
     cirq.XX**0.25,

cirq/transformers/analytical_decompositions/two_qubit_to_ms.py

@@ -19,11 +19,11 @@ Gate compilation methods implemented here are following the paper below:
     arXiv:1603.07678
 """
 
-from typing import Iterable, List, Optional, cast, Tuple, TYPE_CHECKING
+from typing import cast, Iterable, List, Optional, Tuple, TYPE_CHECKING
 
 import numpy as np
 
-from cirq import ops, linalg, protocols
+from cirq import linalg, ops, protocols
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions, two_qubit_to_cz
 
 if TYPE_CHECKING:

cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap.py

@@ -25,7 +25,7 @@ from typing import Optional, Sequence, Tuple, TYPE_CHECKING
 import numpy as np
 import sympy
 
-from cirq import circuits, ops, linalg, protocols
+from cirq import circuits, linalg, ops, protocols
 from cirq.transformers.analytical_decompositions import single_qubit_decompositions
 from cirq.transformers.merge_single_qubit_gates import merge_single_qubit_gates_to_phxz
 
@@ -426,7 +426,7 @@ def _single_qubit_matrices_with_sqrt_iswap(
     for can_decompose, decomposer in decomposers:
         if can_decompose(kak.interaction_coefficients, weyl_tol=atol / 10):
             return decomposer(kak, atol)
-    assert False, 'The final can_decompose should always returns True'
+    assert False, 'The final can_decompose should always returns True'  # pragma: no cover
 
 
 def _in_0_region(

cirq/transformers/analytical_decompositions/two_qubit_to_sqrt_iswap_test.py

@@ -13,11 +13,12 @@
 # limitations under the License.
 
 import itertools
+
 import numpy as np
 import pytest
+import sympy
 
 import cirq
-import sympy
 
 
 def random_unitary(seed):

cirq/transformers/drop_empty_moments.py

@@ -15,6 +15,7 @@
 """Transformer pass that removes empty moments from a circuit."""
 
 from typing import Optional, TYPE_CHECKING
+
 from cirq.transformers import transformer_api, transformer_primitives
 
 if TYPE_CHECKING:

cirq/transformers/drop_negligible_operations.py

@@ -15,6 +15,7 @@
 """Transformer pass that removes operations with tiny effects."""
 
 from typing import Optional, TYPE_CHECKING
+
 from cirq import protocols
 from cirq.transformers import transformer_api, transformer_primitives