Commit 7323a04a authored by Francois Mares's avatar Francois Mares
Browse files
parents 7354bc54 e8789cc8
...@@ -5,53 +5,95 @@ import copy ...@@ -5,53 +5,95 @@ import copy
import itertools import itertools
from config import * from config import *
class GrapheCompositionAleatoire(GC):
"""Construit un graphe de composition aléatoire.""" # class GrapheCompositionAleatoire(GC):
# """Construit un graphe de composition aléatoire."""
def __init__(self, nb_objets = None, nb_morph = None, proba_brancher:float=1/100): # 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. # """`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, # `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. # 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 # Si la probabilité est 0, tous les cycles seront des isomorphismes
et les flèches de obj vers obj seront idempotents.""" # et les flèches de obj vers obj seront idempotents."""
GC.__init__(self,"Graphe de composition aléatoire") # GC.__init__(self,"Graphe de composition aléatoire")
if nb_objets == None: # if nb_objets == None:
nb_objets = random.randint(5,20) # nb_objets = random.randint(5,20)
if nb_morph == None: # if nb_morph == None:
nb_morph = random.randint(0,30) # nb_morph = random.randint(0,30)
if PRINT_AVANCEMENT_CREATION_CAT_ALEA: # if PRINT_AVANCEMENT_CREATION_CAT_ALEA:
print("Création d'une catégorie avec "+str(nb_objets)+" objets et "+str(nb_morph)+" morphismes") # print("Création d'une catégorie avec "+str(nb_objets)+" objets et "+str(nb_morph)+" morphismes")
for i in range(nb_objets): #ajout des objets # for i in range(nb_objets): #ajout des objets
self |= {i} # self |= {i}
for i in range(nb_morph): # ajout des morphismes # for i in range(nb_morph): # ajout des morphismes
source = random.randint(0,nb_objets-1) # source = random.randint(0,nb_objets-1)
cible = random.randint(0,nb_objets-1) # cible = random.randint(0,nb_objets-1)
self |= {MGC(source,cible)} # self |= {MGC(source,cible)}
## on définit la loi de composition pour les cycles # on définit la loi de composition pour les cycles
for obj in self.objets: # for obj in self.objets:
cycles_minimaux = self.trouver_cycles_minimaux(obj,inclure_id=False) # cycles_minimaux = self.trouver_cycles_minimaux(obj,inclure_id=False)
cycles_finaux = cycles_minimaux # cycles_finaux = cycles_minimaux
cycles_graines = set(cycles_minimaux) # cycles qui ont un chance de brancher # cycles_graines = set(cycles_minimaux) # cycles qui ont un chance de brancher
while len(cycles_graines) > 0: # while len(cycles_graines) > 0:
cycle = cycles_graines.pop() # cycle = cycles_graines.pop()
if random.random() < proba_brancher: # if random.random() < proba_brancher:
#on branche # on branche
nouveaux_cycles = {c@cycle for c in cycles_minimaux} # nouveaux_cycles = {c@cycle for c in cycles_minimaux}
cycles_finaux |= nouveaux_cycles # cycles_finaux |= nouveaux_cycles
cycles_graines |= nouveaux_cycles # cycles_graines |= nouveaux_cycles
#maintenant on a tous les cycles finaux # maintenant on a tous les cycles finaux
nb_cycles = len(cycles_finaux)+1 # nb_cycles = len(cycles_finaux)+1
monoide_alea = MonoideAleatoire() # monoide_alea = MonoideAleatoire()
if PRINT_AVANCEMENT_CREATION_CAT_ALEA: # if PRINT_AVANCEMENT_CREATION_CAT_ALEA:
print("Fin création") # print("Fin création")
if TOUJOURS_VERIFIER_COHERENCE: # if TOUJOURS_VERIFIER_COHERENCE:
self.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')
def test_GrapheCompositionAleatoire(): def test_GrapheCompositionAleatoire():
random.seed(1) random.seed(1)
GCA = GrapheCompositionAleatoire() GCA = GrapheCompositionAleatoire()
......
...@@ -44,12 +44,12 @@ class CategorieHomologue(CatFinies): ...@@ -44,12 +44,12 @@ class CategorieHomologue(CatFinies):
continue continue
dict_fleches_k_source = defaultdict(lambda: defaultdict(frozenset)) #{(a,b):{k:{flecheComma1(k),flecheComma2(k),...}}} dict_fleches_k_source = defaultdict(lambda: defaultdict(frozenset)) #{(a,b):{k:{flecheComma1(k),flecheComma2(k),...}}}
for a,b in itertools.product(source.objets,repeat=2): for a,b in itertools.product(source.objets,repeat=2):
for fleche in source[source.objets,source.objets]: for fleche in source[{a},{b}]:
dict_fleches_k_source[(a,b)][fleche.k] |= {fleche} dict_fleches_k_source[(a,b)][fleche.k] |= {fleche}
dict_fleches_k_cible = defaultdict(lambda: defaultdict(frozenset)) #{(a,b):{k:{flecheComma1(k),flecheComma2(k),...}}} dict_fleches_k_cible = defaultdict(lambda: defaultdict(frozenset)) #{(a,b):{k:{flecheComma1(k),flecheComma2(k),...}}}
for a,b in itertools.product(cible.objets,repeat=2): for a,b in itertools.product(cible.objets,repeat=2):
for fleche in cible[cible.objets,cible.objets]: #on peut viser que les flèches elem puisqu'on doit commuter avec le foncteur d'oubli qui mène des flèches elem à des flèches elem for fleche in cible[{a},{b}]: #on peut viser que les flèches elem puisqu'on doit commuter avec le foncteur d'oubli qui mène des flèches elem à des flèches elem
dict_fleches_k_cible[(a,b)][fleche.k] |= {fleche} dict_fleches_k_cible[(a,b)][fleche.k] |= {fleche}
bijections_objets = set() # bijections entre cônes de même nadir bijections_objets = set() # bijections entre cônes de même nadir
...@@ -66,9 +66,19 @@ class CategorieHomologue(CatFinies): ...@@ -66,9 +66,19 @@ class CategorieHomologue(CatFinies):
for k in dict_fleches_k_source[(a,b)]: for k in dict_fleches_k_source[(a,b)]:
cat_bij |= {dict_fleches_k_source[(a,b)][k],dict_fleches_k_cible[(bij_obj[a],bij_obj[b])][k]} cat_bij |= {dict_fleches_k_source[(a,b)][k],dict_fleches_k_cible[(bij_obj[a],bij_obj[b])][k]}
bijections = cat_bij({dict_fleches_k_source[(a,b)][k]},{dict_fleches_k_cible[(bij_obj[a],bij_obj[b])][k]}) bijections = cat_bij({dict_fleches_k_source[(a,b)][k]},{dict_fleches_k_cible[(bij_obj[a],bij_obj[b])][k]})
bijections_fleches |= {bijections} bijections_fleches |= {bijections}
bijections_fleches = set()
for a,b in itertools.product(source.objets,repeat=2):
for k in dict_fleches_k_source[(a,b)]:
cat_bij |= {dict_fleches_k_source[(a,b)][k],dict_fleches_k_cible[(bij_obj[a],bij_obj[b])][k]}
bijections = cat_bij({dict_fleches_k_source[(a,b)][k]},{dict_fleches_k_cible[(bij_obj[a],bij_obj[b])][k]})
bijections_fleches |= {bijections}
for bijection_fleche in produit_cartesien_generateurs(*bijections_fleches): for bijection_fleche in produit_cartesien_generateurs(*bijections_fleches):
bij_fleche = dict([x for bij in bijection_fleche for x in bij.as_dict().items()]) bij_fleche = dict([x for bij in bijection_fleche for x in bij.as_dict().items()])
print("yield")
yield Foncteur(source,cible,bij_obj,bij_fleche) yield Foncteur(source,cible,bij_obj,bij_fleche)
...@@ -125,6 +135,38 @@ def test_CategorieHomologue(): ...@@ -125,6 +135,38 @@ def test_CategorieHomologue():
f.transformer_graphviz() f.transformer_graphviz()
g.transformer_graphviz() g.transformer_graphviz()
def test_CategorieHomologue2():
from GrapheDeComposition import GC,MGC
from Diagramme import DiagrammeObjets
gc = GC()
gc |= set("ABCDEFGHIJ")
f,g,h,i,j,k,l,m,n,o,p,q,r,s = [MGC('C','A','f'),MGC('C','B','g'),MGC('D','A','h'),MGC('D','B','i'),MGC('E','A','j'),MGC('E','B','k'),MGC('F','A','l'),MGC('F','B','m'),
MGC('A','G','n'),MGC('A','H','o'),MGC('B','H','p'),MGC('B','I','q'),MGC('I','J','r'),MGC('J','J','s')]
gc |= {f,g,h,i,j,k,l,m,n,o,p,q,r,s}
MGC.identifier_morphismes(s@s,s)
gc.transformer_graphviz()
gc.transformer_graphviz(complet=False)
d1 = DiagrammeObjets(gc,set("CD"))
d2 = DiagrammeObjets(gc,set("EF"))
c_p1 = ChampActif(d1)
c_p2 = ChampActif(d2)
c_p1.transformer_graphviz()
c_p2.transformer_graphviz()
cph = CategorieHomologue({c_p1,c_p2})
cph.transformer_graphviz()
f,g = set(cph.isomorphismes(c_p1,c_p2)).pop()
f.transformer_graphviz()
g.transformer_graphviz()
for cocone in c_p1.objets_cocones("H"):
Cocone(cocone).transformer_graphviz()
if __name__ == '__main__': if __name__ == '__main__':
# test_FoncteurOubli() test_FoncteurOubli()
test_CategorieHomologue() test_CategorieHomologue()
\ No newline at end of file test_CategorieHomologue2()
\ No newline at end of file
...@@ -210,7 +210,9 @@ def test_EnsFinis(): ...@@ -210,7 +210,9 @@ def test_EnsFinis():
def test_EnsParties(): def test_EnsParties():
cat = EnsParties({1,2,3}) cat = EnsParties({1,2,3})
cat.transformer_graphviz(limite_fleches=27) cat.transformer_graphviz(complet=False)
for app in cat({frozenset({1,2,3})},{frozenset({1,2})}):
app.transformer_graphviz()
def test_CategorieBijections(): def test_CategorieBijections():
cat = EnsParties({1,2,3}) cat = EnsParties({1,2,3})
...@@ -220,6 +222,6 @@ def test_CategorieBijections(): ...@@ -220,6 +222,6 @@ def test_CategorieBijections():
cat.transformer_graphviz(limite_fleches=27) cat.transformer_graphviz(limite_fleches=27)
if __name__ == '__main__': if __name__ == '__main__':
test_EnsFinis() # test_EnsFinis()
# test_EnsParties() test_EnsParties()
# test_CategorieBijections() # test_CategorieBijections()
\ No newline at end of file
...@@ -16,14 +16,6 @@ d1.transformer_graphviz() ...@@ -16,14 +16,6 @@ d1.transformer_graphviz()
d2.transformer_graphviz() d2.transformer_graphviz()
c_p1 = ChampActif(d1) c_p1 = ChampActif(d1)
# obj = set(c_p1.objets).pop()
# Cocone(obj).transformer_graphviz()
# fleches = c_p1({obj},{obj})
# fleche = fleches.pop()
# fleche.h.transformer_graphviz()
# fleche = fleches.pop()
# fleche.h.transformer_graphviz()
c_p2 = ChampActif(d2) c_p2 = ChampActif(d2)
# c_p1.transformer_graphviz(complet=False) # c_p1.transformer_graphviz(complet=False)
# c_p1.transformer_graphviz(complet=True) # c_p1.transformer_graphviz(complet=True)
...@@ -36,12 +28,8 @@ sous_c_p1.transformer_graphviz() ...@@ -36,12 +28,8 @@ sous_c_p1.transformer_graphviz()
sous_c_p2 = SousCategoriePleine(c_p2,c_p2.objets_colimites()) sous_c_p2 = SousCategoriePleine(c_p2,c_p2.objets_colimites())
sous_c_p2.transformer_graphviz() sous_c_p2.transformer_graphviz()
print("hom")
cat_hom = CategorieHomologue({sous_c_p1,sous_c_p2}) cat_hom = CategorieHomologue({sous_c_p1,sous_c_p2})
iso = cat_hom.existe_isomorphisme(sous_c_p1,sous_c_p2) cat_hom.transformer_graphviz()
for fonct in iso:
fonct.transformer_graphviz()
fonct.source.transformer_graphviz()
from Cluster import CategorieClusters from Cluster import CategorieClusters
......
...@@ -5,6 +5,7 @@ from CategorieProduit import CategorieProduit ...@@ -5,6 +5,7 @@ from CategorieProduit import CategorieProduit
import random import random
from config import * from config import *
import itertools import itertools
from typing import *
class ElementMonoide(Morphisme): class ElementMonoide(Morphisme):
"""Un élément de monoïde est une flèche de l'unique objet (1) de la catégorie vers lui-même.""" """Un élément de monoïde est une flèche de l'unique objet (1) de la catégorie vers lui-même."""
...@@ -21,24 +22,21 @@ class Monoide(CategorieLibre): ...@@ -21,24 +22,21 @@ class Monoide(CategorieLibre):
La loi de composition de la catégorie représente la loi de composition interne. La loi de composition de la catégorie représente la loi de composition interne.
Les classes filles doivent implémenter les méthodes : Les classes filles doivent implémenter les méthodes :
- identite(self,objet:any = None) -> Morphisme: renvoie l'element neutre peu import l'objet - identite(self,objet:Any = None) -> Morphisme: renvoie l'element neutre peu import l'objet
- elements(self) -> set : renvoie l'ensemble des éléments du Monoïde où chaque élément est un ElementMonoide. - elements(self) -> set : renvoie l'ensemble des éléments du Monoïde où chaque élément est un ElementMonoide.
ces deux méthodes définissent le graphe sous-jacent avec les objets de la catégorie""" ces deux méthodes définissent le graphe sous-jacent avec les objets de la catégorie"""
def __init__(self, objet:any = 1, nom:str = "Monoide"): def __init__(self, nom:str = "Monoide"):
CategorieLibre.__init__(self,{objet},nom) CategorieLibre.__init__(self,{1},nom)
def __ior__(self, objets:set): def __ior__(self, objets:set) -> "Monoide":
if objets == {1}: if objets == {1}:
CategorieLibre.__ior__(self,{1}) CategorieLibre.__ior__(self,{1})
return self return self
raise Exception("Tentative d'ajout d'un objet à un monoide : "+str(objets)) raise Exception("Tentative d'ajout d'un objet à un monoide : "+str(objets))
def __isub__(self, objets:set): def __isub__(self, objets:set) -> "Monoide":
raise Exception("Tentative de retirer un objet à un monoide : "+str(objets)) raise Exception("Tentative de retirer un objet à un monoide : "+str(objets))
def existe_morphisme(self, source:any, cible:any) -> bool:
return source == cible == 1
def identite(self) -> ElementMonoide: def identite(self) -> ElementMonoide:
raise NotImplementedError("Les classes filles doivent implementer cette methode qui renvoie l'element neutre.") raise NotImplementedError("Les classes filles doivent implementer cette methode qui renvoie l'element neutre.")
...@@ -63,13 +61,13 @@ class MonoideGC(GrapheDeComposition,Monoide): ...@@ -63,13 +61,13 @@ class MonoideGC(GrapheDeComposition,Monoide):
C'est un graphe de composition à un objet.""" C'est un graphe de composition à un objet."""
def __init__(self,nom:str = "MonoïdeGC"): def __init__(self,nom:str = "MonoïdeGC"):
GrapheDeComposition.__init__(self,{1},nom) GrapheDeComposition.__init__(self,nom)
Monoide.__init__(self,nom=nom) Monoide.__init__(self,nom=nom)
def identite(self, objet:any = None) -> ElementMonoideGC: def identite(self, objet:Any = None) -> ElementMonoideGC:
return GrapheDeComposition.identite(self,1) return GrapheDeComposition.identite(self,1)
def elements(self) -> set: def elements(self) -> Generator[Morphisme,None,None]:
return GrapheDeComposition.__call__(self,{1},{1}) return GrapheDeComposition.__call__(self,{1},{1})
def __ior__(self, elements:set) -> 'MonoideGC': def __ior__(self, elements:set) -> 'MonoideGC':
...@@ -181,7 +179,7 @@ class MonoideAleatoire(CategorieProduit,Monoide): ...@@ -181,7 +179,7 @@ class MonoideAleatoire(CategorieProduit,Monoide):
CategorieProduit.__init__(self,*self) CategorieProduit.__init__(self,*self)
Monoide.__init__(self,tuple(1 for i in range(len(self))),nom) Monoide.__init__(self,tuple(1 for i in range(len(self))),nom)
def __ior__(self, objets:set): def __ior__(self, objets:set) -> 'MonoideAleatoire':
if objets == {tuple(1 for i in range(len(self)))}: if objets == {tuple(1 for i in range(len(self)))}:
CategorieLibre.__ior__(self,{tuple(1 for i in range(len(self)))}) CategorieLibre.__ior__(self,{tuple(1 for i in range(len(self)))})
return self return self
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment