checkpoint

Author: NoureldinYosri

qualtran/rotation_synthesis/channels/channel.py

@@ -132,19 +132,28 @@ def to_cirq(self, fmt: str = "xz", qs: Optional[Sequence[cirq.Qid]] = None) -> c
             q = cirq.q(0)
         return cirq.Circuit(ctr.to_cirq(self.to_matrix(), fmt, q))
 
-    def to_quirk(self, fmt: str = "xz") -> str:
+    def to_quirk(self, fmt: str = "xz", allow_global_phase: bool = False) -> str:
         """Retruns a quirk link representing the channel operation.
 
         Args:
             fmt: The gates to use (see the documentation of to_sequence).
+            allow_global_phase: whether the result can have a global phase or not.
+                If this is set then each gate (except H) gets replaced by SU2 version:
+                    - S -> Rz(pi/2)
+                    - T -> Rz(pi/4)
+                    - X -> Rx(-pi)
+                    - Y -> Ry(-pi)
+                    - Z -> Rz(-pi)
+                Then a prefix composed of SXSX that corrects the phase difference caused by H gates
+                is added.
         Returns:
             A quirk link.
         Raises:
             ValueError: If twirl=True
         """
         if self.twirl:
             raise ValueError("to_quirk is not supported when twirl=True")
-        gates = ctr.to_quirk(self.to_matrix(), fmt)
+        gates = ctr.to_quirk(self.to_matrix(), fmt, allow_global_phase)
         cols = '[' + ','.join(f'[{g}]' for g in gates) + ']'
         return "https://algassert.com/quirk#circuit={\"cols\":%s}" % cols
 
@@ -277,30 +286,43 @@ def to_cirq(self, fmt: str = "xz", qs: Optional[Sequence[cirq.Qid]] = None) -> c
             ),
         )
 
-    def to_quirk(self, fmt: str = "xz") -> str:
+    def to_quirk(self, fmt: str = "xz", allow_global_phase: bool = False) -> str:
         """Retruns a quirk link representing the channel operation.
 
         Args:
             fmt: The gates to use (see the documentation of to_sequence).
+            allow_global_phase: whether the result can have a global phase or not.
+                If this is set then each gate (except H) gets replaced by SU2 version:
+                    - S -> Rz(pi/2)
+                    - T -> Rz(pi/4)
+                    - X -> Rx(-pi)
+                    - Y -> Ry(-pi)
+                    - Z -> Rz(-pi)
+                Then a prefix composed of SXSX that corrects the phase difference caused by H gates
+                is added.
         Returns:
             A quirk link.
         """
         correction = self.correction
         if not isinstance(correction, UnitaryChannel):
             raise ValueError(f"to_quirk is not supported for correction of type {type(correction)}")
-        rot = ctr.to_quirk(self.rotation.to_matrix(), fmt)
-        cor = ctr.to_quirk(correction.to_matrix(), fmt)
+        rot = ctr.to_quirk(self.rotation.to_matrix(), fmt, allow_global_phase)
+        cor = ctr.to_quirk(correction.to_matrix(), fmt, allow_global_phase)
+        if allow_global_phase:
+            xgate = '"X"'
+        else:
+            xgate = '{"id":"Rzft","arg":"-pi"}'
         first_row = []
         second_row = []
         # CNOT
         first_row.append("\"•\"")
-        second_row.append("\"X\"")
+        second_row.append(xgate)
         # rotation
         first_row.extend(rot)
         second_row.extend("1" for _ in rot)
         # CNOT
         first_row.append("\"•\"")
-        second_row.append("\"X\"")
+        second_row.append(xgate)
         # measure
         first_row.append("1")
         second_row.append("\"Measure\"")

qualtran/rotation_synthesis/matrix/clifford_t_repr.py

@@ -52,26 +52,31 @@ def _xyz_sequence(matrix: su2_ct.SU2CliffordT) -> tuple[str, ...]:
 ]
 
 
-def _xz_sequence(matrix: su2_ct.SU2CliffordT, use_hs: bool = True) -> Optional[tuple[str, ...]]:
+def _xz_sequence(matrix: su2_ct.SU2CliffordT, use_hs: bool = True, prv: str = 'dummy') -> Optional[tuple[str, ...]]:
+    # if use_hs:
+        # matrix = matrix.reduce()
     if matrix.det() == 2:
         return clifford(matrix)
     cliffords = [su2_ct.ISqrt2]
     if use_hs:
         cliffords.append(su2_ct.HSqrt2)
         cliffords.append(su2_ct.HSqrt2 @ su2_ct.SSqrt2)
     candidates = []
+    pref = prv.removesuffix('*')
     for name, t in _T_list:
+        if name.startswith(pref): continue
         for c in cliffords:
             new = c.adjoint() @ matrix
             new = t.adjoint() @ new
             new = new.scale_down()
             if new is None or not new.is_valid():
                 continue
-            seq = _xz_sequence(new, False)
+            seq = _xz_sequence(new, False, name)
             if seq is None:
                 continue
             gates = cast(tuple[str, ...], c.gates)
             candidates.append(seq + (name,) + gates)
+            break
     if not candidates:
         return None
     return min(candidates, key=len)
@@ -113,19 +118,34 @@ def to_sequence(matrix: su2_ct.SU2CliffordT, fmt: str = 'xyz') -> tuple[str, ...
 }
 
 
-def _to_quirk_name(name: str) -> str:
-    if name == "I":
-        return "1"
-    if name in ("X", "Y", "Z", "H"):
-        return "\"" + name + "\""
-    if name == "S":
-        return "\"Z^½\""
-    if name == "S*":
-        return "\"Z^-½\""
-    if name.startswith("T"):
-        if name.endswith("*"):
-            return "\"" + name[1].upper() + "^-¼" + "\""
-        return "\"" + name[1].upper() + "^¼" + "\""
+def _to_quirk_name(name: str, allow_global_phase: bool = False) -> str:
+    if allow_global_phase:
+        if name == "I":
+            return "1"
+        if name in ("X", "Y", "Z", "H"):
+            return "\"" + name + "\""
+        if name == "S":
+            return "\"Z^½\""
+        if name == "S*":
+            return "\"Z^-½\""
+        if name.startswith("T"):
+            if name.endswith("*"):
+                return "\"" + name[1].upper() + "^-¼" + "\""
+            return "\"" + name[1].upper() + "^¼" + "\""
+    else:
+        if name == "I":
+            return "1"
+        if name == "H":
+            return "\"H\""
+        if name in ("X", "Y", "Z"):
+            return '{"id":"R%sft","arg":"-pi"}'%(name.lower())
+        if name == "S":
+            return '{"id":"Rzft","arg":"pi/2"}'
+        if name == "S*":
+            return '{"id":"Rzft","arg":"-pi/2"}'
+        if name.startswith("T"):
+            angle = ['pi/4', '-pi/4'][name.endswith('*')]
+            return '{"id":"R%sft","arg":"%s"}'%(name[1].lower(), angle)
     raise ValueError(f"{name=} is not supported")
 
 
@@ -145,13 +165,27 @@ def to_cirq(
     return tuple(_CIRQ_GATE_MAP[g](q) for g in to_sequence(matrix, fmt))
 
 
-def to_quirk(matrix: su2_ct.SU2CliffordT, fmt: str) -> tuple[str, ...]:
+def to_quirk(matrix: su2_ct.SU2CliffordT, fmt: str, allow_global_phase: bool = False) -> tuple[str, ...]:
     """Retruns a representation of the matrix as a sequence of quirk symbols.
 
     Args:
         matrix: The matrix to represent.
         fmt: The gates to use (see the documentation of to_sequence).
+        allow_global_phase: whether the result can have a global phase or not.
+            If this is set then each gate (except H) gets replaced by SU2 version:
+                - S -> Rz(pi/2)
+                - T -> Rz(pi/4)
+                - X -> Rx(-pi)
+                - Y -> Ry(-pi)
+                - Z -> Rz(-pi)
+            Then a prefix composed of SXSX that corrects the phase difference caused by H gates
+            is added.
     Returns:
         A tuple quirk symbols.
     """
-    return tuple(_to_quirk_name(name) for name in to_sequence(matrix, fmt))
+    sequence = to_sequence(matrix, fmt)
+    phase_correction = ()
+    if not allow_global_phase:
+        phase = sum(g=='H' for g in sequence) % 4
+        phase_correction = ('"Z^½"', '"X"', '"Z^½"', '"X"') * phase
+    return phase_correction + tuple(_to_quirk_name(name, allow_global_phase) for name in sequence)

qualtran/rotation_synthesis/matrix/clifford_t_repr_test.py

@@ -41,11 +41,28 @@ def test_to_xyz_seq(g):
     got = su2_ct.SU2CliffordT.from_sequence(seq)
     assert got == g
 
+def reduce(g: su2_ct.SU2CliffordT):
+    import qualtran.rotation_synthesis.rings.zsqrt2 as z2
+    import qualtran.rotation_synthesis.rings.zw as zw
+    if not(g.det() > 2 * z2.LAMBDA_KLIUCHNIKOV):
+        return g
+    if not all(v.is_divisible_by(zw.LAMBDA_KLIUCHNIKOV) for v in g.matrix.flat):
+        return g
+    return reduce(su2_ct.SU2CliffordT([[v//zw.LAMBDA_KLIUCHNIKOV for v in r] for r in g.matrix]))
 
 @pytest.mark.parametrize("g", _make_random_su(50, 5, random_cliffords=True, seed=0))
 def test_to_xz_seq(g):
+    g = reduce(g)
     seq = ctr.to_sequence(g, 'xz')
     assert not any('Ty' in g for g in seq)
+    first_t = None
+    for i in range(len(seq)):
+        if seq[i].startswith('T'):
+            first_t = i
+            break
+    if first_t is not None:
+        ts = 'Tx', 'Tx*', 'Tz', 'Tz*'
+        assert all(s in ts for s in seq[first_t:-2]), f'{seq=}'
     got = su2_ct.SU2CliffordT.from_sequence(seq)
     assert got == g