Merge branch 'master' of https://gitlab.utc.fr/gsabbagh/modification-de-categories.git

CategorieAleatoire.py

@@ -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()

CategorieHomologue.py

@@ -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

EnsFinis.py

@@ -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

ExemplesCategories.py

@@ -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
 

Monoide.py

@@ -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