waveforms 1.8.5__tar.gz → 1.8.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: waveforms
-Version: 1.8.5
+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.5 → 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,30 +94,30 @@ def test_subgroup():
     assert not G < SymmetricGroup(5)
 
 
-def test_express():
-    N = 2
-    DEPTH = 1000
-
-    generators = make_clifford_generators(N)
+def test_simplify():
+    group = SymmetricGroup(5)
 
-    clifford = PermutationGroup(list(generators.values()))
+    lst1 = []
+    for i in range(100):
+        lst1.append(group.random())
 
-    circuit = random_circuit(
-        N, DEPTH, ['X/2', 'Y/2', 'X', 'Y', '-X/2', '-Y/2', 'Z', 'S', '-S'],
-        ['CZ', 'iSWAP', 'Cnot'])
-    U = seq2mat(circuit)
+    perm = functools.reduce(operator.mul, lst1)
+    perm2 = perm.inv()
 
-    circ_perm = find_permutation_for_Unitary(U, N)
-    inv_circ = clifford.express(circ_perm.inv())
+    assert (perm * perm2).is_identity()
 
-    assert (
-        circ_perm *
-        functools.reduce(operator.mul, expand_expr(inv_circ))).is_identity()
+    perm.simplify()
 
-    reversed_map = {v: k for k, v in generators.items()}
-    inv_circuit = [reversed_map[c] for c in expand_expr(inv_circ)]
+    lst2 = []
+    for g, n in perm._expr:
+        for _ in range(n):
+            lst2.append(g)
 
-    U = seq2mat(circuit + inv_circuit)
-    U = U * np.exp(-1j * np.angle(U[0, 0]))
+    assert functools.reduce(operator.mul, lst2) == perm
 
-    assert np.allclose(U, np.eye(U.shape[0]))
+    perm2 = group.express(perm2)
+    perm2.simplify()
+    for g, n in perm2._expr:
+        for _ in range(n):
+            lst2.append(g)
+    assert functools.reduce(operator.mul, lst2) == Cycles()

{waveforms-1.8.5 → 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.5 → waveforms-1.8.7}/waveforms/math/group/__init__.py

@@ -1,4 +1,5 @@
 from ._SU_n_ import SU
+from .clifford.funtions import cliffordOrder
 from .clifford.group import CliffordGroup
 from .permutation_group import (AlternatingGroup, Cycles, CyclicGroup,
                                 DihedralGroup, PermutationGroup,

waveforms-1.8.7/waveforms/math/group/clifford/__init__.py

@@ -0,0 +1,4 @@
+from .funtions import (cliffordOrder, one_qubit_clifford_matricies,
+                       one_qubit_clifford_mul_table, one_qubit_clifford_seq,
+                       two_qubit_clifford_matricies, twoQubitCliffordSequence)
+from .group import CliffordGroup, find_permutation_for_Unitary

waveforms-1.8.7/waveforms/math/group/clifford/funtions.py

@@ -0,0 +1,232 @@
+import operator
+from functools import lru_cache, reduce
+
+import numpy as np
+from numpy import pi
+
+from waveforms.cache import cache
+
+from ...matricies import U
+
+
+def cliffordOrder(n: int) -> int:
+    """
+    Order of complex Clifford group of degree 2^n arising in quantum coding theory.
+    
+    Sloane, N. J. A. (ed.). "Sequence A003956 (Order of Clifford group)".
+    The On-Line Encyclopedia of Integer Sequences. OEIS Foundation.
+    https://oeis.org/A003956
+    """
+    return reduce(operator.mul, (((1 << (2 * j)) - 1) << 2 * j + 1
+                                 for j in range(1, n + 1)), 1)
+
+
+one_qubit_clifford_seq = [
+    # Paulis
+    ("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", 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", 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", 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 = {
+    g: i
+    for i, g in enumerate(one_qubit_clifford_seq)
+}
+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],
+    [1,0,3,2,6,7,4,5,11,10,9,8,13,12,18,19,22,23,14,15,21,20,16,17],
+    [2,3,0,1,7,6,5,4,10,11,8,9,20,21,15,14,23,22,19,18,12,13,17,16],
+    [3,2,1,0,5,4,7,6,9,8,11,10,21,20,19,18,17,16,15,14,13,12,23,22],
+    [4,7,5,6,11,8,9,10,2,3,1,0,22,17,21,12,14,18,13,20,23,16,15,19],
+    [5,6,4,7,10,9,8,11,1,0,2,3,23,16,12,21,19,15,20,13,22,17,18,14],
+    [6,5,7,4,8,11,10,9,3,2,0,1,16,23,20,13,18,14,12,21,17,22,19,15],
+    [7,4,6,5,9,10,11,8,0,1,3,2,17,22,13,20,15,19,21,12,16,23,14,18],
+    [8,9,11,10,1,3,2,0,7,4,5,6,19,14,22,16,20,12,23,17,15,18,13,21],
+    [9,8,10,11,2,0,1,3,6,5,4,7,14,19,23,17,13,21,22,16,18,15,20,12],
+    [10,11,9,8,3,1,0,2,4,7,6,5,18,15,17,23,12,20,16,22,14,19,21,13],
+    [11,10,8,9,0,2,3,1,5,6,7,4,15,18,16,22,21,13,17,23,19,14,12,20],
+    [12,13,21,20,18,19,14,15,22,17,23,16,1,0,4,5,8,10,6,7,2,3,11,9],
+    [13,12,20,21,14,15,18,19,16,23,17,22,0,1,6,7,11,9,4,5,3,2,8,10],
+    [14,19,15,18,22,16,23,17,20,21,12,13,8,9,2,0,6,4,1,3,10,11,7,5],
+    [15,18,14,19,17,23,16,22,12,13,20,21,10,11,0,2,5,7,3,1,8,9,4,6],
+    [16,23,22,17,12,21,20,13,19,14,15,18,5,6,8,11,3,0,10,9,7,4,1,2],
+    [17,22,23,16,21,12,13,20,14,19,18,15,4,7,9,10,0,3,11,8,6,5,2,1],
+    [18,15,19,14,16,22,17,23,21,20,13,12,11,10,3,1,4,6,0,2,9,8,5,7],
+    [19,14,18,15,23,17,22,16,13,12,21,20,9,8,1,3,7,5,2,0,11,10,6,4],
+    [20,21,13,12,19,18,15,14,17,22,16,23,3,2,7,6,10,8,5,4,0,1,9,11],
+    [21,20,12,13,15,14,19,18,23,16,22,17,2,3,5,4,9,11,7,6,1,0,10,8],
+    [22,17,16,23,13,20,21,12,15,18,19,14,7,4,11,8,2,1,9,10,5,6,0,3],
+    [23,16,17,22,20,13,12,21,18,15,14,19,6,5,10,9,1,2,8,11,4,7,3,0],
+], 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 个群元对应的操作序列
+    """
+    S1 = [0, 8, 7]  #  I, Rot(2/3 pi, (1,1,1)), Rot(2/3 pi, (1,-1,-1))
+    if n < 576:
+        i, j = np.unravel_index(n, (24, 24))
+        return ((i, ), (j, ))
+    elif n < 5760:
+        n -= 576
+        i, j, k, l = np.unravel_index(n, (24, 24, 3, 3))
+        return ((i, 'CX', S1[k]), (j, 'CX', S1[l]))
+    elif n < 10944:
+        n -= 5760
+        i, j, k, l = np.unravel_index(n, (24, 24, 3, 3))
+        return ((i, 'iSWAP', S1[k]), (j, 'iSWAP', S1[l]))
+    else:
+        n -= 10944
+        i, j = np.unravel_index(n, (24, 24))
+        return ((i, 'SWAP'), (j, 'SWAP'))
+
+
+@cache()
+def _matricies():
+    one_qubit_clifford_matricies = [U(*g[1:]) for g in one_qubit_clifford_seq]
+    two_qubit_clifford_matricies = []
+    for n in range(11520):
+        seq = twoQubitCliffordSequence(n)
+        mat = np.eye(4, dtype=complex)
+        for a, b in zip(*seq):
+            if isinstance(a, str):
+                mat = {
+                    'CX':
+                    np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1],
+                              [0, 0, 1, 0]]),
+                    'iSWAP':
+                    np.array([[1, 0, 0, 0], [0, 0, 1j, 0], [0, 1j, 0, 0],
+                              [0, 0, 0, 1]]),
+                    'SWAP':
+                    np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0],
+                              [0, 0, 0, 1]])
+                }[a] @ mat
+            else:
+                mat = np.kron(one_qubit_clifford_matricies[a],
+                              one_qubit_clifford_matricies[b]) @ mat
+
+        two_qubit_clifford_matricies.append(mat)
+    return one_qubit_clifford_matricies, two_qubit_clifford_matricies
+
+
+one_qubit_clifford_matricies, two_qubit_clifford_matricies = _matricies()