PDCS/F2_N.py at master · a-corni/PDCS · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
import numpy as np
import sys
from Classic_algebra import *
from Classic_generators import *
np.set_printoptions(threshold=sys.maxsize)
import csv


def linear_subspace(n):

    # Retourne tous les sous-ensembles commutatifs d'opérateurs de Pauli de taille N
    #O(N**2*2**(N**2)+ N**4 + (C(N,2N)*2**N)**2) = O(N**2*2**(N**2) + 2**(6N)) = O(N**2*2**(N**2))

    # liste des sous-ensembles commutatifs d'opérateurs de Pauli
    linearsubspace = []

    # Chaque générateur d'un ensemble commutatif d'opérateur de Pauli s'écrit [A,B] avec A,B des matrices carrées ne contenant que des 0 et des 1
    MnF2 = Mn_F2(n) #O(N**2*2**(N**2))

    for A in MnF2 : #n**2 call

        for B in MnF2 :#n**2 call

            # générateur
            M = np.concatenate((A,B),axis=1) #1 operation

            # on génère un groupe commutatif de matrices de Pauli si M = [A,B] est de rang n
            if np.linalg.matrix_rank(M) == n: # C(2n,n)*2**n matrices

                # on regarde si M ne génère pas le même ensemble qu'un générateur déjà observé
                hasappeared = False
                m = len(linearsubspace)

                # on parcourt la liste des ensembles déjà générés
                for indexsubspace in range(m): # unknown but maximal C(2n,n)*2**n

                    subspace = linearsubspace[indexsubspace]
                    representant = subspace[0]

                    # on compare notre générateur à un générateur déjà trouvé
                    if are_equivalent(M, representant): #O(n*2**N)

                        # s'ils génèrent le même groupe
                        # on stocke la matrice M au format (A,B) dans la même liste que le générateur comparé
                        linearsubspace[indexsubspace].append((A,B))
                        hasappeared = True

                if not hasappeared :

                    # sinon
                    # on crée un nouveau groupe de matrices équivalentes.
                    linearsubspace.append([M, (A,B)])

    return linearsubspace

def linear_subset_new_condition(N):

    #liste des matrices commutatives
    linear_subsets = []

    MnF2 = Mn_F2(N) #O(N**2*2**(N**2))

    I = np.eye(N,dtype=int)
    zero = np.zeros((N,N),dtype=int)

    for A in MnF2 :

        M = np.concatenate((I,A), axis = 1)
        generated_subsets = permutation(M)

        for generated_subset in generated_subsets :

            # on regarde si M ne génère pas le même ensemble qu'un générateur déjà observé
            hasappeared = False
            m = len(linear_subsets)

            # on parcourt la liste des ensembles déjà générés
            for indexsubset in range(m): # unknown but maximal C(2n,n)*2**n

                subset = linear_subsets[indexsubset]
                representant = subset[0]

                # on compare notre générateur à un générateur déjà trouvé
                if are_equivalent(generated_subset, representant): #O(N*2**N)

                    # s'ils génèrent le même groupe
                    # on stocke la matrice M au format (A,B) dans la même liste que le générateur comparé
                    linear_subsets[indexsubset].append(generated_subset)
                    hasappeared = True

            if not hasappeared :

                # sinon
                # on crée un nouveau groupe de matrices équivalentes.
                linear_subsets.append([M])


    return linear_subsets

def linear_subspace_toprint_txt(n):

    fichier = open("linear_subspace_"+str(n)+".txt", "w")
    linearsubspace = linear_subspace(n)
    understoodable = []

    for subspace in linearsubspace:

        n = len(subspace)
        (A,B) = subspace[1]
        subspacename = sub_pauli(A,B)
        understoodable.append(subspacename)
        fichier.write(str(subspacename) + " Il y a " + str(n-1)+ " matrices équivalentes :" +"\n")

        for i in range(1,n):

            understoodable.append(subspace[i])
            fichier.write(str(subspace[i]) + ", "+"\n")

        understoodable.append(n-1)
        fichier.write("\n")

    fichier.close()

    return understoodable

def linear_subspace_toprint_csv(n):


    fichier = open("linear_subspace_"+str(n)+".csv", "wt")
    linearsubspaceCSV = csv.writer(fichier,delimiter=";")

    linearsubspace = linear_subspace(n)

    for subspace in linearsubspace:

        (A,B) = subspace[1]
        subspacename = sub_pauli(A,B)
        commutative_subset = [subspacename[0], subspacename[1]]
        for i in range(2, 2**n) :
            new_pauli_operator = subspacename[i]
            commute_with_all = True
            for  pauli_operator in commutative_subset :
                if not commute(new_pauli_operator, pauli_operator,n):
                    commute_with_all = False
                    break
            if commute_with_all :
                commutative_subset.append(new_pauli_operator)
        if len(commutative_subset)==len(subspacename):
            linearsubspaceCSV.writerow(subspacename)

    fichier.close()