waveforms 1.8.6__tar.gz → 1.8.7__tar.gz

{waveforms-1.8.6/waveforms.egg-info → waveforms-1.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: waveforms
-Version: 1.8.6
+Version: 1.8.7
 Summary: Edit waveforms used in experiment
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>

waveforms-1.8.7/tests/test_SUN.py

@@ -0,0 +1,15 @@
+import numpy as np
+
+from waveforms.math.group import SU
+
+
+def test_SU():
+    for N in range(2, 6):
+        for i in range(N**2):
+            mat = SU(N)[i]
+            assert mat.shape == (N, N)
+            if i == 0:
+                assert np.allclose(mat, np.eye(N))
+            else:
+                assert abs(np.trace(mat)) < 1e-9
+            assert np.allclose(mat, mat.T.conj())

waveforms-1.8.7/tests/test_clifford.py

@@ -0,0 +1,135 @@
+import functools
+import itertools
+import operator
+import random
+
+import numpy as np
+
+from waveforms.math.group import CliffordGroup, PermutationGroup
+from waveforms.math.group.clifford import (cliffordOrder,
+                                           find_permutation_for_Unitary)
+from waveforms.math.group.clifford.funtions import (
+    one_qubit_clifford_matricies, one_qubit_clifford_mul_table,
+    one_qubit_clifford_seq, one_qubit_clifford_seq2)
+from waveforms.math.group.clifford.group import make_clifford_generators
+from waveforms.math.matricies import synchronize_global_phase
+from waveforms.qlisp.simulator.simple import applySeq, seq2mat
+
+
+def make_circuit(gate, N):
+    rest_qubits = set(range(N)) - set(gate[1:])
+    circ = [gate]
+    for qubit in rest_qubits:
+        circ.append(('I', qubit))
+    return circ
+
+
+def random_circuit(N, depth, single_qubit_gate_set, two_qubit_gate_set):
+    circ = []
+    qubits = list(range(N))
+    for i in range(depth):
+        for q in range(N):
+            circ.append((random.choice(single_qubit_gate_set), q))
+        random.shuffle(qubits)
+        for i in range(0, N - 1, 2):
+            circ.append(
+                (random.choice(two_qubit_gate_set), qubits[i], qubits[i + 1]))
+    return circ
+
+
+def test_cliffordOrder():
+    assert cliffordOrder(0) == 1
+    assert cliffordOrder(1) == 24
+    assert cliffordOrder(2) == 11520
+    assert cliffordOrder(3) == 92897280
+
+    for N in [1, 2, 3]:
+        clifford = PermutationGroup(list(make_clifford_generators(N).values()))
+        assert clifford.order() == cliffordOrder(N)
+
+
+def test_mul_table():
+    group = CliffordGroup(1)
+    lst = [
+        group.circuit_to_permutation([(g, 0)]) for g in one_qubit_clifford_seq
+    ]
+    for i, j in itertools.product(range(24), repeat=2):
+        assert lst[i] * lst[j] == lst[one_qubit_clifford_mul_table[i, j]]
+
+
+def test_mul_table2():
+    for i, j in itertools.product(range(24), repeat=2):
+        assert np.allclose(
+            synchronize_global_phase(one_qubit_clifford_matricies[j]
+                                     @ one_qubit_clifford_matricies[i]),
+            synchronize_global_phase(
+                one_qubit_clifford_matricies[one_qubit_clifford_mul_table[i,
+                                                                          j]]))
+
+
+def test_seq2():
+    for mat, seq in zip(one_qubit_clifford_matricies, one_qubit_clifford_seq2):
+        assert np.allclose(
+            synchronize_global_phase(mat),
+            synchronize_global_phase(seq2mat([(g, 0) for g in seq])))
+
+
+def test_elements():
+    group = CliffordGroup(1)
+    lst = [
+        group.circuit_to_permutation([(g, 0)]) for g in one_qubit_clifford_seq
+    ]
+    assert len(group.elements) == 24
+    assert set(group.elements) == set(lst)
+
+
+def test_rb():
+    group = CliffordGroup(2)
+
+    circ = []
+    for i in range(500):
+        circ.extend(group.permutation_to_circuit(group.random()))
+
+    circ2 = group.circuit_simplify(circ)
+    circ3 = group.circuit_fullsimplify(circ)
+    assert len(circ3) < len(circ)
+
+    circ.extend(group.circuit_inv(circ3))
+    circ2.extend(group.circuit_inv(circ3))
+    circ3.extend(group.circuit_inv(circ3))
+
+    psi = applySeq(circ)
+    assert abs((psi * psi.conj()).real[0] - 1) < 1e-6
+
+    psi = applySeq(circ2)
+    assert abs((psi * psi.conj()).real[0] - 1) < 1e-6
+
+    psi = applySeq(circ3)
+    assert abs((psi * psi.conj()).real[0] - 1) < 1e-6
+
+
+def test_express():
+    N = 2
+    DEPTH = 1000
+
+    generators = make_clifford_generators(N)
+
+    clifford = PermutationGroup(list(generators.values()))
+
+    circuit = random_circuit(
+        N, DEPTH, ['X/2', 'Y/2', 'X', 'Y', '-X/2', '-Y/2', 'Z', 'S', '-S'],
+        ['CZ', 'iSWAP', 'Cnot'])
+    U = seq2mat(circuit)
+
+    circ_perm = find_permutation_for_Unitary(U, N)
+    inv_circ = clifford.express(circ_perm.inv())
+
+    assert (circ_perm *
+            functools.reduce(operator.mul, inv_circ.expand())).is_identity()
+
+    reversed_map = {v: k for k, v in generators.items()}
+    inv_circuit = [reversed_map[c] for c in inv_circ.expand()]
+
+    U = seq2mat(circuit + inv_circuit)
+
+    assert np.allclose(synchronize_global_phase(U), np.eye(U.shape[0]))

{waveforms-1.8.6 → waveforms-1.8.7}/tests/test_group.py

@@ -1,77 +1,7 @@
 import functools
-import itertools
 import operator
-import random
-from functools import reduce
-from itertools import chain, product
-
-import numpy as np
 
 from waveforms.math.group import *
-from waveforms.math.group.clifford.funtions import cliffordOrder
-from waveforms.qlisp.simulator.simple import seq2mat
-
-
-def make_circuit(gate, N):
-    rest_qubits = set(range(N)) - set(gate[1:])
-    circ = [gate]
-    for qubit in rest_qubits:
-        circ.append(('I', qubit))
-    return circ
-
-
-def find_permutation_for_Unitary(U, N):
-    init = []
-    final = []
-    for base in product([
-            SU(2)[0],
-            SU(2)[1],
-            SU(2)[2],
-            SU(2)[3], -SU(2)[0], -SU(2)[1], -SU(2)[2], -SU(2)[3]
-    ],
-                        repeat=N):
-        op = reduce(np.kron, base)
-        init.append(op)
-        final.append(U @ op @ U.T.conj())
-    return find_permutation(init, final)
-
-
-def random_circuit(N, depth, single_qubit_gate_set, two_qubit_gate_set):
-    circ = []
-    qubits = list(range(N))
-    for i in range(depth):
-        for q in range(N):
-            circ.append((random.choice(single_qubit_gate_set), q))
-        random.shuffle(qubits)
-        for i in range(0, N - 1, 2):
-            circ.append(
-                (random.choice(two_qubit_gate_set), qubits[i], qubits[i + 1]))
-    return circ
-
-
-def expand_expr(perm):
-    perm.simplify()
-    expr = perm._expr
-    return itertools.chain.from_iterable([[c] * n for c, n in expr])
-
-
-def make_clifford_generators(N):
-    gate_list = []
-
-    for q in range(N):
-        gate_list.append(('H', q))
-        gate_list.append(('S', q))
-
-    for q in range(N - 1):
-        gate_list.append(('CZ', q, q + 1))
-
-    generators = {}
-
-    for gate in gate_list:
-        U = seq2mat(make_circuit(gate, N))
-        generators[gate] = find_permutation_for_Unitary(U, N)
-
-    return generators
 
 
 def test_init():
@@ -93,10 +23,6 @@ def test_order():
     ])
     assert G.order() == 88179840
 
-    for N in [1, 2, 3]:
-        clifford = PermutationGroup(list(make_clifford_generators(N).values()))
-        assert clifford.order() == cliffordOrder(N)
-
 
 def test_orbit():
     G = SymmetricGroup(5)
@@ -168,35 +94,6 @@ def test_subgroup():
     assert not G < SymmetricGroup(5)
 
 
-def test_express():
-    N = 2
-    DEPTH = 1000
-
-    generators = make_clifford_generators(N)
-
-    clifford = PermutationGroup(list(generators.values()))
-
-    circuit = random_circuit(
-        N, DEPTH, ['X/2', 'Y/2', 'X', 'Y', '-X/2', '-Y/2', 'Z', 'S', '-S'],
-        ['CZ', 'iSWAP', 'Cnot'])
-    U = seq2mat(circuit)
-
-    circ_perm = find_permutation_for_Unitary(U, N)
-    inv_circ = clifford.express(circ_perm.inv())
-
-    assert (
-        circ_perm *
-        functools.reduce(operator.mul, expand_expr(inv_circ))).is_identity()
-
-    reversed_map = {v: k for k, v in generators.items()}
-    inv_circuit = [reversed_map[c] for c in expand_expr(inv_circ)]
-
-    U = seq2mat(circuit + inv_circuit)
-    U = U * np.exp(-1j * np.angle(U[0, 0]))
-
-    assert np.allclose(U, np.eye(U.shape[0]))
-
-
 def test_simplify():
     group = SymmetricGroup(5)
 

{waveforms-1.8.6 → waveforms-1.8.7}/waveforms/math/group/_SU_n_.py

@@ -1,9 +1,10 @@
 import math
+
 import numpy as np
 
 
 def _SUn_generator(n, i):
-    assert n > 1 and 0 <= i < 2**n
+    assert n > 1 and 0 <= i < n**2
 
     if i == 0:
         return np.eye(n, dtype=np.int8), 1
@@ -36,8 +37,8 @@ class _SUGroup():
         self.n = n
 
     def __getitem__(self, i: int):
-        if not 0 <= i < 2**self.n:
-            raise IndexError(f"i must be in [0, {2**self.n-1}]")
+        if not 0 <= i < self.n**2:
+            raise IndexError(f"i must be in [0, {self.n**2-1}]")
         mat, A = _SUn_generator(self.n, i)
         return A * mat
 
@@ -46,4 +47,4 @@ class _SUGroup():
 
 
 def SU(n: int):
-    return _SUGroup(n)
+    return _SUGroup(n)

{waveforms-1.8.6 → waveforms-1.8.7}/waveforms/math/group/clifford/funtions.py

@@ -1,5 +1,5 @@
 import operator
-from functools import reduce
+from functools import lru_cache, reduce
 
 import numpy as np
 from numpy import pi
@@ -23,36 +23,70 @@ def cliffordOrder(n: int) -> int:
 
 one_qubit_clifford_seq = [
     # Paulis
-    ("u3", 0 / 6 * pi,  0 / 6 * pi,  0 / 6 * pi), # I
-    ("u3", 6 / 6 * pi, -6 / 6 * pi,  0 / 6 * pi), # X
-    ("u3", 6 / 6 * pi,  0 / 6 * pi,  0 / 6 * pi), # Y
-    ("u3", 0 / 6 * pi,  3 / 6 * pi,  3 / 6 * pi), # Z
+    ("u3", 0   ,  0   ,  0   ), # I
+    ("u3", pi  , -pi  ,  0   ), # X
+    ("u3", pi  ,  0   ,  0   ), # Y
+    ("u3", 0   ,  pi/2,  pi/2), # Z
 
     # 2 pi / 3 rotations
-    ("u3", 3 / 6 * pi, -3 / 6 * pi,  0 / 6 * pi),
-    ("u3", 3 / 6 * pi, -3 / 6 * pi,  6 / 6 * pi),
-    ("u3", 3 / 6 * pi,  3 / 6 * pi,  0 / 6 * pi),
-    ("u3", 3 / 6 * pi,  3 / 6 * pi, -6 / 6 * pi),
-    ("u3", 3 / 6 * pi,  0 / 6 * pi,  3 / 6 * pi),
-    ("u3", 3 / 6 * pi,  0 / 6 * pi, -3 / 6 * pi),
-    ("u3", 3 / 6 * pi, -6 / 6 * pi,  3 / 6 * pi),
-    ("u3", 3 / 6 * pi,  6 / 6 * pi, -3 / 6 * pi),
+    ("u3", pi/2, -pi/2,  0   ),
+    ("u3", pi/2, -pi/2,  pi  ),
+    ("u3", pi/2,  pi/2,  0   ),
+    ("u3", pi/2,  pi/2, -pi  ),
+    ("u3", pi/2,  0   ,  pi/2),
+    ("u3", pi/2,  0   , -pi/2),
+    ("u3", pi/2, -pi  ,  pi/2),
+    ("u3", pi/2,  pi  , -pi/2),
 
     # pi / 2 rotations
-    ("u3", 3 / 6 * pi, -3 / 6 * pi,  3 / 6 * pi), #  X/2
-    ("u3", 3 / 6 * pi,  3 / 6 * pi, -3 / 6 * pi), # -X/2
-    ("u3", 3 / 6 * pi,  0 / 6 * pi,  0 / 6 * pi), #  Y/2
-    ("u3", 3 / 6 * pi,  6 / 6 * pi, -6 / 6 * pi), # -Y/2
-    ("u3", 0 / 6 * pi,  0 / 6 * pi,  3 / 6 * pi), #  Z/2
-    ("u3", 0 / 6 * pi,  0 / 6 * pi, -3 / 6 * pi), # -Z/2
+    ("u3", pi/2, -pi/2,  pi/2), #  X/2
+    ("u3", pi/2,  pi/2, -pi/2), # -X/2
+    ("u3", pi/2,  0   ,  0   ), #  Y/2
+    ("u3", pi/2,  pi  , -pi  ), # -Y/2
+    ("u3", 0   ,  0   ,  pi/2), #  Z/2
+    ("u3", 0   ,  0   , -pi/2), # -Z/2
 
     # Hadamard-like
-    ("u3", 3 / 6 * pi, -6 / 6 * pi,  0 / 6 * pi),
-    ("u3", 3 / 6 * pi,  0 / 6 * pi,  6 / 6 * pi), # Hadamard
-    ("u3", 3 / 6 * pi,  3 / 6 * pi,  3 / 6 * pi),
-    ("u3", 3 / 6 * pi, -3 / 6 * pi, -3 / 6 * pi),
-    ("u3", 6 / 6 * pi, -3 / 6 * pi,  0 / 6 * pi),
-    ("u3", 6 / 6 * pi,  3 / 6 * pi,  0 / 6 * pi)
+    ("u3", pi/2, -pi  ,  0   ),
+    ("u3", pi/2,  0   ,  pi  ), # Hadamard
+    ("u3", pi/2,  pi/2,  pi/2),
+    ("u3", pi/2, -pi/2, -pi/2),
+    ("u3", pi  , -pi/2,  0   ),
+    ("u3", pi  ,  pi/2,  0   )
+] #yapf: disable
+
+one_qubit_clifford_seq2 = [
+    # Paulis
+    [],                              # I
+    ['H', 'S', 'S', 'H'],            # X
+    ['H', 'S', 'S', 'H', 'S', 'S'],  # Y
+    ['S', 'S'],                      # Z
+
+    # 2 pi / 3 rotations
+    ['S', 'S', 'H', 'S', 'S', 'S'],
+    ['H', 'S', 'S', 'S'],
+    ['S', 'S', 'H', 'S'],
+    ['H', 'S'],
+    ['S', 'S', 'S', 'H'],
+    ['S', 'H'],
+    ['S', 'S', 'S', 'H', 'S', 'S'],
+    ['S', 'H', 'S', 'S'],
+
+    # pi / 2 rotations
+    ['S', 'S', 'S', 'H', 'S', 'S', 'S'], #  X/2
+    ['S', 'H', 'S'],                     # -X/2
+    ['S', 'S', 'H'],                     #  Y/2
+    ['H', 'S', 'S'],                     # -Y/2
+    ['S'],                               #  Z/2
+    ['S', 'S', 'S'],                     # -Z/2
+
+    # Hadamard-like
+    ['S', 'S', 'H', 'S', 'S'],
+    ['H'],
+    ['S', 'S', 'S', 'H', 'S'],
+    ['S', 'H', 'S', 'S', 'S'],
+    ['H', 'S', 'S', 'H', 'S'],
+    ['H', 'S', 'S', 'H', 'S', 'S', 'S']
 ] #yapf: disable
 
 one_qubit_clifford_seq_inv = {
@@ -62,6 +96,15 @@ one_qubit_clifford_seq_inv = {
 one_qubit_clifford_seq_inv['H'] = 19
 one_qubit_clifford_seq_inv['S'] = 16
 one_qubit_clifford_seq_inv['I'] = 0
+one_qubit_clifford_seq_inv['X'] = 1
+one_qubit_clifford_seq_inv['Y'] = 2
+one_qubit_clifford_seq_inv['Z'] = 3
+one_qubit_clifford_seq_inv['X/2'] = 12
+one_qubit_clifford_seq_inv['-X/2'] = 13
+one_qubit_clifford_seq_inv['Y/2'] = 14
+one_qubit_clifford_seq_inv['-Y/2'] = 15
+one_qubit_clifford_seq_inv['-S'] = 17
+one_qubit_clifford_seq_inv.update({f'C1_{i}': i for i in range(24)})
 
 one_qubit_clifford_mul_table = np.array([
     [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23],
@@ -91,6 +134,51 @@ one_qubit_clifford_mul_table = np.array([
 ], dtype=np.int8) #yapf: disable
 
 
+@lru_cache()
+def _one_qubit_clifford_index(gate):
+    pass
+
+
+def one_qubit_clifford_index(gate):
+    if gate in one_qubit_clifford_seq_inv:
+        return one_qubit_clifford_seq_inv[gate]
+    else:
+        match gate:
+            case ('R', phi):
+                return one_qubit_clifford_index(
+                    ('U', pi / 2, phi - pi / 2, pi / 2 - phi))
+            case ('rfUnitary', theta, phi):
+                return one_qubit_clifford_index(
+                    ('U', theta, phi - pi / 2, pi / 2 - phi))
+            case ('u3', theta, phi, lam) | ('U', theta, phi, lam):
+                theta = np.mod(theta / (2 * pi))
+                if theta == np.pi / 2:
+                    pass
+                elif theta == 0:
+                    phi, lam = phi + lam, 0
+                elif theta == np.pi:
+                    phi, lam = phi - lam, 0
+                elif theta == 3 * np.pi / 2:
+                    theta = np.pi / 2
+                    phi, lam = phi + pi, lam + pi
+                else:
+                    return -1
+                phi = np.mod(phi, 2 * pi)
+                lam = np.mod(lam, 2 * pi)
+            case ('u2', phi, lam):
+                return one_qubit_clifford_index(('U', pi / 2, phi, lam))
+            case ('u1', lam) | ('Rz', lam) | ('P', lam):
+                return one_qubit_clifford_index(('U', 0, 0, lam))
+            case 'P':
+                return 16
+            case ('Rx', theta):
+                return one_qubit_clifford_index(('U', theta, -pi / 2, pi / 2))
+            case ('Ry', theta):
+                return one_qubit_clifford_index(('U', theta, 0, 0))
+            case _:
+                return -1
+
+
 def twoQubitCliffordSequence(n):
     """
     生成第 n 个群元对应的操作序列

{waveforms-1.8.6 → waveforms-1.8.7}/waveforms/math/group/clifford/group.py

@@ -1,90 +1,67 @@
 import itertools
 import random
 from functools import reduce
-from itertools import product
+from itertools import islice, product
 
 import numpy as np
 
 from waveforms.cache import cache
 from waveforms.qlisp.simulator.simple import seq2mat
 
+from ...paulis import encode_paulis
 from .._SU_n_ import SU
 from ..permutation_group import Cycles, PermutationGroup, find_permutation
+from .chp import CZ, H, P
 from .funtions import (cliffordOrder, one_qubit_clifford_mul_table,
                        one_qubit_clifford_seq, one_qubit_clifford_seq_inv)
 
-_base = [SU(2)[i] for i in range(4)] + [-SU(2)[i] for i in range(4)]
-
-
-def make_circuit(gate, N):
-    rest_qubits = set(range(N)) - set(gate[1:])
-    circ = [gate]
-    for qubit in rest_qubits:
-        circ.append(('I', qubit))
-    return circ
-
 
 def find_permutation_for_Unitary(U, N):
     init = []
     final = []
 
-    for index in product(range(8), repeat=N):
-        if all(i == 0 or i == 4 for i in index):
-            continue
-        op = reduce(np.kron, [_base[i] for i in index])
+    for s in islice(product([SU(2)[i] for i in range(4)], repeat=N), 1, None):
+        op = reduce(np.kron, s)
         init.append(op)
         final.append(U @ op @ U.T.conj())
+        init.append(-op)
+        final.append(U @ (-op) @ U.T.conj())
     return find_permutation(init, final)
 
 
-def random_circuit(N, depth, single_qubit_gate_set, two_qubit_gate_set):
-    circ = []
-    qubits = list(range(N))
-    for i in range(depth):
-        for q in range(N):
-            circ.append((random.choice(single_qubit_gate_set), q))
-        random.shuffle(qubits)
-        for i in range(0, N - 1, 2):
-            circ.append(
-                (random.choice(two_qubit_gate_set), qubits[i], qubits[i + 1]))
-    return circ
-
+def make_clifford_generators(N, graph=None):
+    if graph is None:
+        graph = []
+        for i in range(N - 1):
+            graph.append((i, i + 1))
 
-@cache()
-def make_clifford_generators(N,
-                             one_qubit_gates=('H', 'S'),
-                             two_qubit_gates=('CZ', ),
-                             gate_list=None):
-    if gate_list is None:
-        gate_list = []
-
-        for q in range(N):
-            for gate in one_qubit_gates:
-                gate_list.append((gate, q))
-
-        for q in range(N - 1):
-            for gate in two_qubit_gates:
-                gate_list.append((gate, q, q + 1))
+    stablizers = []
+    for s in islice(product('IXYZ', repeat=N), 1, None):
+        n = encode_paulis(''.join(s))
+        stablizers.append(n)
+        stablizers.append(n | 2)
 
     generators = {}
 
-    for gate in gate_list:
-        U = seq2mat(make_circuit(gate, N))
-        generators[gate] = find_permutation_for_Unitary(U, N)
+    for i in range(N):
+        generators[('H', i)] = find_permutation(stablizers,
+                                                [H(s, i) for s in stablizers])
+        generators[('S', i)] = find_permutation(stablizers,
+                                                [P(s, i) for s in stablizers])
+
+    for i, j in graph:
+        generators[('CZ', i,
+                    j)] = find_permutation(stablizers,
+                                           [CZ(s, i, j) for s in stablizers])
 
     return generators
 
 
 class CliffordGroup(PermutationGroup):
 
-    def __init__(self,
-                 N,
-                 one_qubit_gates=('H', 'S'),
-                 two_qubit_gates=('CZ', ),
-                 gate_list=None):
+    def __init__(self, N, graph=None):
         self.N = N
-        generators = make_clifford_generators(N, one_qubit_gates,
-                                              two_qubit_gates, gate_list)
+        generators = make_clifford_generators(N, graph)
         super().__init__(list(generators.values()))
         self.reversed_map = {v: k for k, v in generators.items()}
         self.gate_map = generators

{waveforms-1.8.6 → waveforms-1.8.7}/waveforms/math/group/permutation_group.py

@@ -206,7 +206,7 @@ class Cycles():
         if isinstance(self._expr, list):
             if self.is_identity():
                 pass
-            if not self._expr:
+            elif not self._expr:
                 self._expr = [[self, 1]]
             return self
 
@@ -264,7 +264,9 @@ def permute(expr: list | tuple | str | bytes | np.ndarray, perm: Cycles):
 
 def _ne(a, b):
     if isinstance(a, np.ndarray):
-        return not np.allclose(a, b)
+        if isinstance(b, np.ndarray):
+            return not np.allclose(a, b)
+        return True
     else:
         return a != b
 

{waveforms-1.8.6 → waveforms-1.8.7}/waveforms/math/matricies.py

@@ -67,7 +67,7 @@ CZ = make_immutable(
     np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]],
              dtype=complex))
 iSWAP = make_immutable(
-    np.array([[1, 0, 0, 0], [0, 1j, 0, 0], [0, 0, 1j, 0], [0, 0, 0, 1]],
+    np.array([[1, 0, 0, 0], [0, 0, 1j, 0], [0, 1j, 0, 0], [0, 0, 0, 1]],
              dtype=complex))
 SWAP = make_immutable(
     np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]],
@@ -173,3 +173,17 @@ def fSim(theta, phi):
         [0, -1j*s,     c,     0],
         [0,     0,     0,     p]
     ]) #yapf: disable
+
+
+def synchronize_global_phase(U):
+    """
+    将第一个非零的矩阵元相位转成 0，以保证仅相差一个全局相位的矩阵具有相同的表示。
+    优先处理对角元，再依次处理下三角阵。
+    """
+    assert U.shape[0] == U.shape[1]
+    for i in range(U.shape[0]):
+        for j in range(U.shape[0] - i):
+            if np.abs(U[j + i, j]) > 1e-9:
+                U = U * np.abs(U[j + i, j]) / U[j + i, j]
+                return U
+    return 0 * U

{waveforms-1.8.6 → waveforms-1.8.7}/waveforms/quantum/clifford/mat.py

@@ -2,20 +2,7 @@ from itertools import count, product
 
 import numpy as np
 
-
-def normalize(mat):
-    """
-    将第一个非零的矩阵元相位转成 0，以保证仅相差一个全局相位的矩阵具有相同的表示。
-    优先处理对角元，再依次处理下三角阵。
-    """
-    assert mat.shape[0] == mat.shape[1]
-    for i in range(mat.shape[0]):
-        for j in range(mat.shape[0] - i):
-            if np.abs(mat[j + i, j]) > 1e-3:
-                mat = mat * np.abs(mat[j + i, j]) / mat[j + i, j]
-                return mat
-    return 0 * mat
-
+from waveforms.math.matricies import synchronize_global_phase
 
 # 相位规范化后，2 比特 Clifford 群元的矩阵元仅可能取以下值
 elms = [
@@ -39,7 +26,7 @@ def mat2num(mat, norm=True):
 
     # 仅相隔一个全局相位的操作等价，故令第一个非零的矩阵元相位为 0，保证操作与矩阵一一对应
     if norm:
-        mat = normalize(mat)
+        mat = synchronize_global_phase(mat)
 
     absData, phaseData = 0, 0
     for index, (i, j) in zip(count(start=0, step=2), product(range(4),