Merge pull request #409 from QuTech-Delft/CQT-294-Fix-McKay-decomposer-bug-with-decomposing-Cycling-Cliffords

[CQT-294] Fix mc kay decomposer bug with decomposing cycling cliffords

Author: elenbaasc

opensquirrel/passes/decomposer/mckay_decomposer.py

@@ -2,9 +2,9 @@
 
 from math import atan2, cos, pi, sin, sqrt
 
-from opensquirrel import X90, Rz
+from opensquirrel import X90, I, Rz
 from opensquirrel.common import ATOL, normalize_angle
-from opensquirrel.ir import BlochSphereRotation, Gate
+from opensquirrel.ir import Axis, BlochSphereRotation, Gate
 from opensquirrel.passes.decomposer import ZXZDecomposer
 from opensquirrel.passes.decomposer.general_decomposer import Decomposer
 
@@ -25,20 +25,26 @@ def decompose(self, g: Gate) -> list[Gate]:
             return [g]
 
         if abs(g.angle) < ATOL:
-            return []
+            return [I(g.qubit)]
 
         if g.axis[0] == 0 and g.axis[1] == 0:
             rz_angle = float(g.angle * g.axis[2])
             return [Rz(g.qubit, rz_angle)]
 
         zxz_decomposition = ZXZDecomposer().decompose(g)
         zxz_angle = 0.0
-        if len(zxz_decomposition) >= 2 and isinstance(zxz_decomposition[1], BlochSphereRotation):
-            zxz_angle = zxz_decomposition[1].angle
+        if len(zxz_decomposition) >= 2:
+            zxz_angle = next(
+                gate.angle
+                for gate in zxz_decomposition
+                if isinstance(gate, BlochSphereRotation) and gate.axis == Axis(1, 0, 0)
+            )
 
         if abs(zxz_angle - pi / 2) < ATOL:
-            zxz_decomposition[1] = X90(g.qubit)
-            return zxz_decomposition
+            return [
+                X90(g.qubit) if isinstance(gate, BlochSphereRotation) and gate.axis == Axis(1, 0, 0) else gate
+                for gate in zxz_decomposition
+            ]
 
         # McKay decomposition
         za_mod = sqrt(cos(g.angle / 2) ** 2 + (g.axis[2] * sin(g.angle / 2)) ** 2)

test/decomposer/test_mckay_decomposer.py

@@ -5,7 +5,7 @@
 import numpy as np
 import pytest
 
-from opensquirrel import CNOT, CR, X90, H, I, Rz, X, Y, Z
+from opensquirrel import CNOT, CR, X90, Y90, H, I, Rz, S, Sdag, X, Y, Z, mX90, mY90
 from opensquirrel.ir import BlochSphereRotation, Gate
 from opensquirrel.passes.decomposer import McKayDecomposer
 from opensquirrel.passes.decomposer.general_decomposer import check_gate_replacement
@@ -25,10 +25,11 @@ def test_ignores_2q_gates(decomposer: McKayDecomposer, gate: Gate, expected_resu
     assert decomposer.decompose(gate) == expected_result
 
 
-def test_identity_empty_decomposition(decomposer: McKayDecomposer) -> None:
+def test_identity_decomposition(decomposer: McKayDecomposer) -> None:
     gate = I(0)
     decomposed_gate = decomposer.decompose(gate)
-    assert decomposed_gate == []
+    expected_result = [I(0)]
+    assert decomposed_gate == expected_result
 
 
 def test_x(decomposer: McKayDecomposer) -> None:
@@ -81,3 +82,95 @@ def test_all_octants_of_bloch_sphere_rotation(decomposer: McKayDecomposer) -> No
                 arbitrary_operation = BlochSphereRotation(qubit=0, axis=axis, angle=angle, phase=phase)
                 decomposed_arbitrary_operation = decomposer.decompose(arbitrary_operation)
                 check_gate_replacement(arbitrary_operation, decomposed_arbitrary_operation)
+
+
+@pytest.mark.parametrize(
+    ("gate", "expected_result"),
+    [
+        (I(0), [I(0)]),
+        (X(0), [X90(0), X90(0)]),
+        (Y(0), [Rz(0, math.pi), X90(0), X90(0)]),
+        (Z(0), [Rz(0, math.pi)]),
+        (
+            BlochSphereRotation(
+                qubit=0, axis=[1 / math.sqrt(3), 1 / math.sqrt(3), 1 / math.sqrt(3)], angle=2 * math.pi / 3, phase=0
+            ),
+            [X90(0), Rz(0, math.pi / 2)],
+        ),
+        (
+            BlochSphereRotation(qubit=0, axis=[1, 1, 1], angle=-2 * math.pi / 3, phase=0),
+            [X90(0), Rz(0, math.pi / 2), X90(0), Rz(0, math.pi / 2)],
+        ),
+        (
+            BlochSphereRotation(qubit=0, axis=[-1, 1, 1], angle=2 * math.pi / 3, phase=0),
+            [Rz(0, -math.pi / 2), X90(0), Rz(0, math.pi)],
+        ),
+        (
+            BlochSphereRotation(qubit=0, axis=[-1, 1, 1], angle=-2 * math.pi / 3, phase=0),
+            [Rz(0, -math.pi / 2), X90(0), Rz(0, math.pi / 2), X90(0), Rz(0, math.pi)],
+        ),
+        (BlochSphereRotation(qubit=0, axis=[1, -1, 1], angle=2 * math.pi / 3, phase=0), [Rz(0, math.pi / 2), X90(0)]),
+        (
+            BlochSphereRotation(qubit=0, axis=[1, -1, 1], angle=-2 * math.pi / 3, phase=0),
+            [Rz(0, math.pi / 2), X90(0), Rz(0, math.pi / 2), X90(0)],
+        ),
+        (BlochSphereRotation(qubit=0, axis=[1, 1, -1], angle=2 * math.pi / 3, phase=0), [Rz(0, -math.pi / 2), X90(0)]),
+        (
+            BlochSphereRotation(
+                qubit=0, axis=[1 / math.sqrt(3), 1 / math.sqrt(3), -1 / math.sqrt(3)], angle=-2 * math.pi / 3, phase=0
+            ),
+            [Rz(0, math.pi / 2), X90(0), Rz(0, math.pi / 2), X90(0), Rz(0, math.pi)],
+        ),
+        (X90(0), [X90(0)]),
+        (mX90(0), [Rz(0, math.pi / 2), X90(0), Rz(0, math.pi / 2), X90(0), Rz(0, math.pi / 2)]),
+        (Y90(0), [Rz(0, -math.pi / 2), X90(0), Rz(0, math.pi / 2)]),
+        (mY90(0), [X90(0), Rz(0, math.pi / 2), X90(0), Rz(0, math.pi)]),
+        (S(0), [Rz(0, math.pi / 2)]),
+        (Sdag(0), [Rz(0, -math.pi / 2)]),
+        (H(0), [Rz(0, math.pi / 2), X90(0), Rz(0, math.pi / 2)]),
+        (
+            BlochSphereRotation(qubit=0, axis=[1, 1, 0], angle=math.pi, phase=math.pi / 2),
+            [Rz(0, -3 * math.pi / 4), X90(0), X90(0), Rz(0, -math.pi / 4)],
+        ),
+        (BlochSphereRotation(qubit=0, axis=[0, 1, 1], angle=math.pi, phase=math.pi / 2), [X90(0), Rz(0, math.pi)]),
+        (
+            BlochSphereRotation(qubit=0, axis=[-1, 1, 0], angle=math.pi, phase=math.pi / 2),
+            [Rz(0, 3 * math.pi / 4), X90(0), X90(0), Rz(0, math.pi / 4)],
+        ),
+        (
+            BlochSphereRotation(qubit=0, axis=[1, 0, -1], angle=math.pi, phase=math.pi / 2),
+            [Rz(0, -math.pi / 2), X90(0), Rz(0, -math.pi / 2)],
+        ),
+        (BlochSphereRotation(qubit=0, axis=[0, -1, 1], angle=math.pi, phase=math.pi / 2), [Rz(0, math.pi), X90(0)]),
+    ],
+    ids=[
+        "I",
+        "X",
+        "Y",
+        "Z",
+        "C1",
+        "C2",
+        "C3",
+        "C4",
+        "C5",
+        "C6",
+        "C7",
+        "C8",
+        "X90",
+        "mX90",
+        "Y90",
+        "mY90",
+        "Z90",
+        "mZ90",
+        "H1",
+        "H2",
+        "H3",
+        "H4",
+        "H5",
+        "H6",
+    ],
+)
+def test_single_qubit_clifford_gates(decomposer: McKayDecomposer, gate: Gate, expected_result: list[Gate]) -> None:
+    decomposed_gates = decomposer.decompose(gate)
+    check_gate_replacement(gate, decomposed_gates)
+    assert decomposed_gates == expected_result