Ajout de CatégorieBijections et correction de catégorie homologue pour que ce...

Ajout de CatégorieBijections et correction de catégorie homologue pour que ce soit des bijections plutôt que des applications

CategorieHomologue.py

 from Categorie import Categorie
 from Foncteur import Foncteur
 from CatFinies import CatFinies
-from EnsFinis import EnsFinis,Application
+from EnsFinis import CategorieBijections,Bijection
 from ChampActif import ChampActif,Cocone
 from collections import defaultdict
 import itertools
@@ -16,7 +16,7 @@ class FoncteurOubli(Foncteur):
         {f:f.h for f in champ_actif(abs(champ_actif),abs(champ_actif))})
        
 class CategorieHomologue(CatFinies):
-    """Catégorie dont les objets sont des champs actifs et les morphismes sont des foncteurs qui commutent avec le foncteur d'oubli."""
+    """Catégorie dont les objets sont des champs actifs et les morphismes sont des foncteurs bijectifs qui commutent avec le foncteur d'oubli."""
     
     def verifier_coherence(self):
         CatFinies.verifier_coherence(self)
@@ -41,36 +41,51 @@ class CategorieHomologue(CatFinies):
                     dict_nadir_cocone_cible[Cocone(obj).nadir] |= {obj}
                 if set(dict_nadir_cocone_source.keys()) != set(dict_nadir_cocone_cible.keys()):
                     continue
-                applications_objets = set() # applications entre cocônes de même nadir
-                ens_objets = EnsFinis()
+                bijections_objets = set() # bijections entre cocônes de même nadir
+                ens_objets = CategorieBijections()
+                rate = False
                 for nadir in dict_nadir_cocone_source:
+                    if len(dict_nadir_cocone_source[nadir]) != len(dict_nadir_cocone_cible[nadir]):
+                        rate = True
+                        break
                     ens_objets |= {dict_nadir_cocone_source[nadir]}
                     ens_objets |= {dict_nadir_cocone_cible[nadir]}
-                    applications_objets |= {ens_objets({dict_nadir_cocone_source[nadir]},{dict_nadir_cocone_cible[nadir]})}
-                for application_objet in itertools.product(*applications_objets):
-                    app_obj = dict([x for app in application_objet for x in app.as_dict().items()])
-                    app_fleche_foncteur = dict() # à chaque couple d'objets on associe un ensemble d'applications
+                    bijections_objets |= {frozenset(ens_objets({dict_nadir_cocone_source[nadir]},{dict_nadir_cocone_cible[nadir]}))}
+                if rate:
+                    continue
+                print(len(list(itertools.product(*bijections_objets))))
+                for bijection_objet in itertools.product(*bijections_objets):
+                    bij_obj = dict([x for bij in bijection_objet for x in bij.as_dict().items()])
+                    bij_fleche_foncteur = dict() # à chaque couple d'objets on associe un ensemble de bijections
+                    rate = False
                     for c,d in itertools.product(source.objets, repeat=2):
-                        ens_fleches = EnsFinis({frozenset(source({c},{d})),frozenset(cible({app_obj[c]},{app_obj[d]}))})
-                        app_fleches_c_vers_d = ens_fleches({frozenset(source({c},{d}))},{frozenset(cible({app_obj[c]},{app_obj[d]}))})
-                        app_fleche_foncteur[(c,d)] = app_fleches_c_vers_d
-                        if len(app_fleches_c_vers_d) == 0:
+                        fleches_source_c_vers_d = source({c},{d})
+                        fleches_cibles_c_vers_d = cible({bij_obj[c]},{bij_obj[d]})
+                        if len(fleches_source_c_vers_d) != len(fleches_cibles_c_vers_d):
+                            rate = True
+                            break
+                        ens_fleches = CategorieBijections({frozenset(fleches_source_c_vers_d),frozenset(fleches_cibles_c_vers_d)})
+                        bij_fleches_c_vers_d = ens_fleches({frozenset(source({c},{d}))},{frozenset(cible({bij_obj[c]},{bij_obj[d]}))})
+                        bij_fleche_foncteur[(c,d)] = bij_fleches_c_vers_d
+                        if len(bij_fleches_c_vers_d) == 0:
+                            rate = True
                             break
-                    if len(app_fleche_foncteur[(c,d)]) == 0: #la dernière recherche d'applications à échouée, on passe à l'application objet suivante
+                    if rate: 
                         continue
-                    for applications_fleches in itertools.product(*app_fleche_foncteur.values()):
-                        app_fleches = dict()
-                        for app in applications_fleches:
-                            app_fleches.update(app.as_dict())
+                    print(len(list(itertools.product(*bij_fleche_foncteur.values()))))
+                    for bijections_fleches in itertools.product(*bij_fleche_foncteur.values()):
+                        bij_fleches = dict()
+                        for bij in bijections_fleches:
+                            bij_fleches.update(bij.as_dict())
                         for f in source(abs(source),abs(source)):
                             for g in source(abs(source),{f.source}):
-                                if app_fleches[f@g] != app_fleches[f]@app_fleches[g]:
+                                if bij_fleches[f@g] != bij_fleches[f]@bij_fleches[g]:
                                     break
                             else:
                                 continue
                             break
                         else:
-                            result |= {Foncteur(source,cible,app_obj,app_fleches)}
+                            result |= {Foncteur(source,cible,bij_obj,bij_fleches)}
                     
         return result
         
@@ -107,8 +122,10 @@ def test_CategorieHomologue():
     
     d1 = Fleche(gc,m)
     c_p1 = ChampActif(d1)
+    c_p1.transformer_graphviz()
     d2 = Fleche(gc,n)
     c_p2 = ChampActif(d2)
+    c_p2.transformer_graphviz()
     
     cph = CategorieHomologue({c_p1,c_p2})
     cph.transformer_graphviz()

EnsFinis.py

@@ -103,7 +103,38 @@ class CategorieEnsembleParties(EnsFinis):
             
 EnsParties = CategorieEnsembleParties
     
-    
+class Bijection(Application):
+    def __init__(self, source:frozenset, cible:frozenset, application:dict):
+        Application.__init__(self,source,cible,application)
+        if TOUJOURS_VERIFIER_COHERENCE:
+            self.verifier_coherence()
+
+    def verifier_coherence(self):
+        Application.verifier_coherence(self)
+        if len(source) != len(cible):
+            raise Exception("Incoherence Bijection : il n'y a pas autant d'element au depart qu'a l'arrivee.")
+        if {self(x) for x in source} != set(cible):
+            raise Exception("Incoherence Bijection : toute l'image n'est pas atteinte.")
+
+class CategorieBijections(EnsFinis):
+    """Sous-catégorie d'`EnsFinisCatégorie`.
+    Les objets sont des ensembles et les morphismes sont des applications bijectives."""
+
+    def __init__(self, objets:set = set(), nom:str = "Catégorie des bijections"):
+        EnsFinis.__init__(self,objets,nom)
+
+    def __call__(self, sources:set, cibles:set) -> set:
+       result = set() 
+       for source in sources:
+            for cible in cibles:
+                if len(source) != len(cible):
+                    continue
+                source_liste = list(source)
+                for perm in itertools.permutations(cible):
+                    result |= {Bijection(source,cible,{source_liste[i]:perm[i] for i in range(len(perm))})}
+       return result
+
+
 def test_EnsFinis():
     cat = EnsFinis(set(map(frozenset,[{},{1,2},{3,4,5}])))
     cat.transformer_graphviz()
@@ -117,7 +148,14 @@ def test_EnsFinis():
 def test_EnsParties():
     cat = EnsParties({1,2,3})
     cat.transformer_graphviz()
-    
+
+def test_CategorieBijections():
+    cat = CategorieBijections({frozenset({1,2,3}),frozenset("ABC")})
+    for bij in cat({frozenset({1,2,3})},{frozenset("ABC")}):
+        bij.transformer_graphviz()
+    cat.transformer_graphviz()
+
 if __name__ == '__main__':
     test_EnsFinis()
-    test_EnsParties()
\ No newline at end of file
+    test_EnsParties()
+    test_CategorieBijections()
\ No newline at end of file

ExemplesCategories.py

@@ -28,14 +28,18 @@ c_p2 = ChampActif(d2)
 # c_p1.transformer_graphviz()
 
 
-#sous_c_p1 = SousCategoriePleine(c_p1,c_p1.objets_colimites())
-#sous_c_p1.transformer_graphviz()
+sous_c_p1 = SousCategoriePleine(c_p1,c_p1.objets_colimites())
+sous_c_p1.transformer_graphviz()
 
 
-#sous_c_p2 = SousCategoriePleine(c_p2,c_p2.objets_colimites())
-#sous_c_p2.transformer_graphviz()
+sous_c_p2 = SousCategoriePleine(c_p2,c_p2.objets_colimites())
+sous_c_p2.transformer_graphviz()
 
-from Cluster import CategorieClusters
+print("hom")
+cat_hom = CategorieHomologue({sous_c_p1,sous_c_p2})
+cat_hom.transformer_graphviz()
+
+#from Cluster import CategorieClusters
 
-cat_clust = CategorieClusters(cat,{d1,d2})
-SousCategoriePleine(cat_clust.transformer_graphviz(),{d1,d2}).transformer_graphviz()
\ No newline at end of file
+#cat_clust = CategorieClusters(cat,{d1,d2})
+#SousCategoriePleine(cat_clust.transformer_graphviz(),{d1,d2}).transformer_graphviz()
\ No newline at end of file