Commit 5a7cb5c3 authored by Guillaume Sabbagh's avatar Guillaume Sabbagh
Browse files

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
parent 96465e81
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()
......
......@@ -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
......@@ -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
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