CategorieAleatoire.py 9.79 KB
Newer Older
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
1
from GrapheDeComposition import GC,MGC
2
from Monoide import MonoideAleatoire
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
3
4
5
6
7
import random
import copy
import itertools
from config import *

8
9
10

# class GrapheCompositionAleatoire(GC):
    # """Construit un graphe de composition aléatoire."""
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
11
    
12
13
14
15
16
17
18
19
20
21
22
23
24
    # def __init__(self, nb_objets = None, nb_morph = None, proba_brancher:float=1/100):
        # """`nb_morph` est le nombre de morphismes élémentaires à ajouter aléatoirement.
        # `proba_brancher` est la probabilité de brancher lors de la création de l'arbre de composition des cycles,
        # Plus la probabilité est grande plus il y aura de cycles et plus la loi de composition ne sera pas triviale.
        # Si la probabilité est 0, tous les cycles seront des isomorphismes
        # et les flèches de obj vers obj seront idempotents."""
        # GC.__init__(self,"Graphe de composition aléatoire")
        # if nb_objets == None:
            # nb_objets = random.randint(5,20)
        # if nb_morph == None:
            # nb_morph = random.randint(0,30)
        # if PRINT_AVANCEMENT_CREATION_CAT_ALEA:
            # print("Création d'une catégorie avec "+str(nb_objets)+" objets et "+str(nb_morph)+" morphismes")
25
            
26
27
28
29
30
31
        # for i in range(nb_objets): #ajout des objets
            # self |= {i}
        # for i in range(nb_morph): # ajout des morphismes
            # source = random.randint(0,nb_objets-1)
            # cible = random.randint(0,nb_objets-1)
            # self |= {MGC(source,cible)}
32
        
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
        # on définit la loi de composition pour les cycles
        # for obj in self.objets:
            # cycles_minimaux = self.trouver_cycles_minimaux(obj,inclure_id=False)
            # cycles_finaux = cycles_minimaux
            # cycles_graines = set(cycles_minimaux) # cycles qui ont un chance de brancher
            # while len(cycles_graines) > 0:
                # cycle = cycles_graines.pop()
                # if random.random() < proba_brancher:
                    # on branche
                    # nouveaux_cycles = {c@cycle for c in cycles_minimaux}
                    # cycles_finaux |= nouveaux_cycles
                    # cycles_graines |= nouveaux_cycles
            # maintenant on a tous les cycles finaux
            # nb_cycles = len(cycles_finaux)+1
            # monoide_alea = MonoideAleatoire()
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
        # if PRINT_AVANCEMENT_CREATION_CAT_ALEA:
            # print("Fin création")
        # if TOUJOURS_VERIFIER_COHERENCE:
            # self.verifier_coherence()
  
class GrapheCompositionAleatoire(GC):
    """Construit un graphe de composition aléatoire."""
    def __init__(self, nb_fleches:int = None, nom:str = "Catégorie Aléatoire"):
        if nb_fleches == None:
            nb_fleches = random.randint(5,30)
        
        
        elements = list(range(nb_fleches))
        table = dict()
        for a in elements:
            for b in elements:
                if (a,b) not in table:
                    table[(a,b)] = random.choice(elements)
                    # on force l'associativité si on peut
                    for c in elements:
                        if (table[(a,b)],c) in table and (b,c) in table:
                            if (a,table[(b,c)]) not in table:
                                table[(a,table[(b,c)])] = table[(table[(a,b)],c)]
        elements += [-1]
        for i in elements:
            table[(-1,i)] = i
            table[(i,-1)] = i
                    
        GC.__init__(self)
        #on a une table aléatoire
        #maintenant on vérifie l'associativité
        for a,b,c in itertools.product(elements,repeat=3):
            if table[(a,b)] != "x" and table[(b,c)] != "x" and table[(table[(a,b)],c)] != table[(a,table[(b,c)])]:
                table[(a,b)] = "x"
                table[(b,c)] = "x"
        for a,b,c in itertools.product(elements,repeat=3):
            if table[(a,b)] != "x" and table[(b,c)] != "x" and table[(table[(a,b)],c)] != table[(a,table[(b,c)])]:
                raise Exception(str(a)+" "+str(b)+" "+str(c))
                
        with open("out.csv","w") as f:
            f.write(","+",".join(map(str,elements))+"\n")
            for a in elements:
                f.write(str(a))
                for b in elements:
                    f.write(','+str(table[(a,b)]))
                f.write('\n')
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
97
def test_GrapheCompositionAleatoire():
98
99
    random.seed(1)
    GCA = GrapheCompositionAleatoire()
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
100
    GCA.transformer_graphviz()
101
102
    GCA.loi_de_composition_to_csv('lois de composition/loi_de_compo.csv')
    return GCA
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
103
104
105
            
# class CategorieAleaIsomorph(Categorie):
    # """Construit une catégorie aléatoire où tous les cycles sont des isomorphismes."""
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
106
    
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
    # def __init__(self, nb_objets = None, nb_morph = None):
        # """nb_morph est le nombre de morphismes élémentaires à ajouter aléatoirement."""
        # Categorie.__init__(self,"Catégorie aléatoire")
        # if nb_objets == None:
            # nb_objets = random.randint(5,20)
        # if nb_morph == None:
            # nb_morph = random.randint(0,30)
        # if PRINT_AVANCEMENT_CREATION_CAT_ALEA:
            # print("Création d'une catégorie avec "+str(nb_objets)+" objets et "+str(nb_morph)+" morphismes")
        # self.ajouter_objets(list(range(nb_objets))) # ajout des objets
        # for i in range(nb_morph): # ajout des morphismes
            # pool = [(source,cible) for source,cible in itertools.product(range(nb_objets),repeat=2) if source != cible and len(self.enumerer_composees_sans_cycle(source,cible)) == 0 or len(self.enumerer_composees_sans_cycle(cible,source)) == 0]
            # if len(pool) == 0:
                # break
            # source,cible = random.choice(pool)
            # self.ajouter_morphisme(Morphisme(source,cible,str(i)))
        # on définit la loi de composition pour les cycles
        # for obj in self.objets:
            # cycles = self.trouver_cycles_elementaires(obj)
            # for c in cycles:
                # diag = Parallele(self,[obj]*2,[c,self.identites[obj]])
                # diag.faire_commuter()
        # if PRINT_AVANCEMENT_CREATION_CAT_ALEA:
            # print("Fin création")  
131
            
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
# class CategorieAleaPreOrdre(Categorie):
    # """Construit une catégorie pré-ordre aléatoire."""
    # def __init__(self,nb_objets = None, proportion_morph = None, retirer_obj_isoles = True):
        # """proportion morph est la proportion de morphismes de 0 (graphe sans flèche) à 1 (graphe complet)"""
        # if nb_objets == None:
            # nb_objets = random.randint(5,20)
        # if proportion_morph == None:
            # proportion_morph = min(random.expovariate(10),1)
        # nb_morph = max(int(proportion_morph*(nb_objets)*(nb_objets-1)/2),5) # min 5 morphismes
        # Categorie.__init__(self,"Catégorie pré-ordre aléatoire")
        # self.ajouter_objets(list(range(nb_objets))) #ajout des objets
        # i = 1
        # for source,cible in random.sample(list(itertools.product(range(nb_objets),repeat=2)),nb_morph): # ajout des morphismes
            # self.ajouter_morphisme(Morphisme(source,cible,str(i)))
            # i += 1
        # if retirer_obj_isoles:
            # self.retirer_noeuds_isoles()
        # diag = DiagrammeIdentite(self)
        # diag.faire_commuter()
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
151
                
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
152
153
    # def retirer_noeuds_isoles(self):
        # self.supprimer_objets([obj for obj in self.objets if len(self.morph_sortants[obj]) == len(self.morph_entrants[obj]) == 0])
154

Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
# class CategorieAleaPreOrdreAcyclique(Categorie):
    # """Construit une catégorie pré-ordre aléatoire."""
    # def __init__(self,nb_objets = None, proportion_morph = None, retirer_obj_isoles = True):
        # """proportion morph est la proportion de morphismes de 0 (graphe sans flèche) à 1 (graphe complet)"""
        # if nb_objets == None:
            # nb_objets = random.randint(5,20)
        # if proportion_morph == None:
            # proportion_morph = min(random.expovariate(10),1)
        # nb_morph = max(int(proportion_morph*(nb_objets)*(nb_objets-1)/2),5) # min 5 morphismes
        # Categorie.__init__(self,"Catégorie pré-ordre aléatoire")
        # self.ajouter_objets(list(range(nb_objets))) #ajout des objets
        # i = 1
        # for source,cible in random.sample(list(itertools.combinations(range(nb_objets),2)),nb_morph): # ajout des morphismes
            # self.ajouter_morphisme(Morphisme(source,cible,str(i)))
            # i += 1
        # if retirer_obj_isoles:
            # self.retirer_noeuds_isoles()
        # diag = DiagrammeIdentite(self)
        # diag.faire_commuter()
174
                
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
175
176
    # def retirer_noeuds_isoles(self):
        # self.supprimer_objets([obj for obj in self.objets if len(self.morph_sortants[obj]) == len(self.morph_entrants[obj]) == 0])
177

Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
178
179
180
181
182
183
184
185
186
187
188
189
190
# class DiagrammeAlea(Diagramme):
    # def __init__(self, cat_cible, nb_objets_restants=None, retirer_objets_isoles=True):
        # """nb_objets_restants entre 0 et len(cat_cible.objets)
        # retirer_objets_isoles n'est pas considéré s'il n'y a que des objets isolés"""
        # if nb_objets_restants == None:
            # nb_objets_restants = random.randint(1,len(cat_cible.objets))
        # cat_source = copy.copy(cat_cible)
        # obj_a_suppr = random.sample(cat_cible.objets,len(cat_cible.objets)-nb_objets_restants)
        # print(obj_a_suppr)
        # cat_source.supprimer_objets(obj_a_suppr)
        # if retirer_objets_isoles and len([obj for obj in cat_source.objets if not(len(cat_source.morph_sortants[obj]) == len(cat_source.morph_entrants[obj]) == 0)]) != 0:
            # cat_source.supprimer_objets([obj for obj in cat_source.objets if len(cat_source.morph_sortants[obj]) == len(cat_source.morph_entrants[obj]) == 0])
        # Diagramme.__init__(self,cat_source,cat_cible,{o:o for o in cat_source.objets},{m:m for m in cat_source.morphismes})
191
    
Guillaume Sabbagh's avatar
Guillaume Sabbagh committed
192
193
194

            
if __name__ == '__main__':
195
196
    random.seed(2579)
    test_GrapheCompositionAleatoire()