Commit 7323a04a authored by Francois Mares's avatar Francois Mares
Browse files
parents 7354bc54 e8789cc8
......@@ -5,53 +5,95 @@ import copy
import itertools
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):
"""`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")
# 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")
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)}
# 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)}
## 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()
# 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()
if PRINT_AVANCEMENT_CREATION_CAT_ALEA:
print("Fin création")
if TOUJOURS_VERIFIER_COHERENCE:
self.verifier_coherence()
# 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')
def test_GrapheCompositionAleatoire():
random.seed(1)
GCA = GrapheCompositionAleatoire()
......
......@@ -44,12 +44,12 @@ class CategorieHomologue(CatFinies):
continue
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 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_cible = defaultdict(lambda: defaultdict(frozenset)) #{(a,b):{k:{flecheComma1(k),flecheComma2(k),...}}}
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}
bijections_objets = set() # bijections entre cônes de même nadir
......@@ -66,9 +66,19 @@ class CategorieHomologue(CatFinies):
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}
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):
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)
......@@ -125,6 +135,38 @@ def test_CategorieHomologue():
f.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__':
# test_FoncteurOubli()
test_CategorieHomologue()
\ No newline at end of file
test_FoncteurOubli()
test_CategorieHomologue()
test_CategorieHomologue2()
\ No newline at end of file
......@@ -210,7 +210,9 @@ def test_EnsFinis():
def test_EnsParties():
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():
cat = EnsParties({1,2,3})
......@@ -220,6 +222,6 @@ def test_CategorieBijections():
cat.transformer_graphviz(limite_fleches=27)
if __name__ == '__main__':
test_EnsFinis()
# test_EnsParties()
# test_EnsFinis()
test_EnsParties()
# test_CategorieBijections()
\ No newline at end of file
......@@ -16,14 +16,6 @@ d1.transformer_graphviz()
d2.transformer_graphviz()
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_p1.transformer_graphviz(complet=False)
# c_p1.transformer_graphviz(complet=True)
......@@ -36,12 +28,8 @@ sous_c_p1.transformer_graphviz()
sous_c_p2 = SousCategoriePleine(c_p2,c_p2.objets_colimites())
sous_c_p2.transformer_graphviz()
print("hom")
cat_hom = CategorieHomologue({sous_c_p1,sous_c_p2})
iso = cat_hom.existe_isomorphisme(sous_c_p1,sous_c_p2)
for fonct in iso:
fonct.transformer_graphviz()
fonct.source.transformer_graphviz()
cat_hom.transformer_graphviz()
from Cluster import CategorieClusters
......
......@@ -5,6 +5,7 @@ from CategorieProduit import CategorieProduit
import random
from config import *
import itertools
from typing import *
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."""
......@@ -21,24 +22,21 @@ class Monoide(CategorieLibre):
La loi de composition de la catégorie représente la loi de composition interne.
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.
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"):
CategorieLibre.__init__(self,{objet},nom)
def __init__(self, nom:str = "Monoide"):
CategorieLibre.__init__(self,{1},nom)
def __ior__(self, objets:set):
def __ior__(self, objets:set) -> "Monoide":
if objets == {1}:
CategorieLibre.__ior__(self,{1})
return self
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))
def existe_morphisme(self, source:any, cible:any) -> bool:
return source == cible == 1
def identite(self) -> ElementMonoide:
raise NotImplementedError("Les classes filles doivent implementer cette methode qui renvoie l'element neutre.")
......@@ -63,13 +61,13 @@ class MonoideGC(GrapheDeComposition,Monoide):
C'est un graphe de composition à un objet."""
def __init__(self,nom:str = "MonoïdeGC"):
GrapheDeComposition.__init__(self,{1},nom)
GrapheDeComposition.__init__(self,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)
def elements(self) -> set:
def elements(self) -> Generator[Morphisme,None,None]:
return GrapheDeComposition.__call__(self,{1},{1})
def __ior__(self, elements:set) -> 'MonoideGC':
......@@ -181,7 +179,7 @@ class MonoideAleatoire(CategorieProduit,Monoide):
CategorieProduit.__init__(self,*self)
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)))}:
CategorieLibre.__ior__(self,{tuple(1 for i in range(len(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