Commit cb715b9d authored by Guillaume Sabbagh's avatar Guillaume Sabbagh
Browse files

Categorie Sous est corrigée, c'est maintenant la bonne définition utilisée (celle de Mac Lane)

parent efe02846
......@@ -115,7 +115,7 @@ def main():
cat.transformer_graphviz(afficher_identites=True)
fonct.transformer_graphviz()
print(a,b,fonct)
b.transformer_graphviz()
a.transformer_graphviz()
# cat = Categorie("3")
# cat.ajouter_objets("ABabC")
......
from Categorie import Categorie
from copy import copy
import itertools
from Morphisme import Morphisme, Composition
from Diagramme import Parallele,DiagrammeIdentite
class CategorieSous(Categorie):
"""Soit C une catégorie, et a un objet de C.
CategorieSous n'est pas la catégorie T-en-dessous de a (
(cf. Mac Lane "Categories for the working mathematician" P.46)
class ObjetCategorieFSous:
"""Soit C une catégorie, S un foncteur de I dans C et b un objet de C.
CategorieFSous est la catégorie S-en-dessous de b
(cf. Mac Lane "Categories for the working mathematician" P.45)
Ses objets sont les couples de flèches C(b,S(d)) et d
Ses flèches sont des flèches telles que les triangles formés commutent.
"""
def __init__(self,f,d):
self.f = f
self.d = d
def __repr__(self):
return '('+str(self.f)+','+str(self.d)+')'
class CategorieFSous(Categorie):
"""Soit C une catégorie, S un foncteur de I dans C et b un objet de C.
CategorieFSous est la catégorie S-en-dessous de b
(cf. Mac Lane "Categories for the working mathematician" P.45)
Ses objets sont les couples de flèches C(b,S(d)) et d
Ses flèches sont des flèches telles que les triangles formés commutent.
"""
def __init__(self, foncteur, objet):
Categorie.__init__(self, "Categorie "+str(foncteur.representant)+"-en-dessous l'objet "+str(objet))
categorie = foncteur.cat_cible
self.foncteur = foncteur
self.objet = objet
self.app_index_obj = {} #associe à chaque objet de la catégorie indexante les objets qui ont été générés à partir de lui
# {d : [<C(a,Sd),d>]}
self.app_morph_index = {} #associe à chaque morphisme de cette catégorie le morphisme de la catégorie indexante qui l'a généré
# {f':<C(a,Sd),d>-><C(a,Sd'),d'> : f:d->d'}
self.app_index_morph = {} #inverse de l'application précédente, on ajoute le couple (<C(a,Sd),d>,<C(a,Sd'),d'>) pour rendre l'application bijective
# {(f:d->d',(<C(a,Sd),d>,<C(a,Sd'),d'>)) : f':<C(a,Sd),d>-><C(a,Sd'),d'>}
#on ajoute les objets
for d in foncteur.app_objets:
Sd = foncteur(d)
fleches = categorie.enumerer_composees(objet,Sd)
nouveaux_objets = list(map(lambda f:ObjetCategorieFSous(f,d),fleches))
self.ajouter_objets(nouveaux_objets) #on ajoute les couples (f,d) en tant qu'objets
self.app_index_obj[d] = nouveaux_objets
for obj in nouveaux_objets:
self.app_morph_index[self.identites[obj]] = foncteur.cat_source.identites[d]
self.app_index_morph[(foncteur.cat_source.identites[d],(obj,obj))] = self.identites[obj]
#on ajoute les flèches
for fleche in foncteur.cat_source.morphismes:
for source in self.app_index_obj[fleche.source]:
for cible in self.app_index_obj[fleche.cible]:
if not (source == cible and fleche.is_identite) :
Sh = foncteur(fleche)
if categorie.Composee(source.f,Sh) == cible.f:
morph = Morphisme(source,cible,Sh.representant)
self.ajouter_morphisme(morph)
self.app_morph_index[morph] = fleche
if fleche in self.app_index_morph:
raise Exception(str(fleche)+" deja dans app_index_morph "+str(self.app_index_morph))
self.app_index_morph[(fleche,(source,cible))] = morph
#on fait commuter les flèches
for A,B in itertools.combinations(self.objets,2):
for g in self.morph_sortants[B]:
C = g.cible
for f in self.fleches_elem(A,B,inclure_id=False):
composee_cat_indexante = foncteur.cat_source.Composee(self.app_morph_index[f],self.app_morph_index[g]) #composee de f et g dans la catégorie indexante
if Composition(self.app_morph_index[f],self.app_morph_index[g]) != composee_cat_indexante:
diag = Parallele(self,[A,C],[self.Composee(f,g),self.app_index_morph[(composee_cat_indexante,(A,C))]])
diag.faire_commuter()
class CategorieSous(CategorieFSous):
"""Soit C une catégorie, b un objet de C.
CategorieSous est la catégorie en-dessous de b
(cf. Mac Lane "Categories for the working mathematician" P.45)
Ses objets sont les couples de flèches C(b,c) et c
Ses flèches sont des flèches telles que les triangles formés commutent.
"""
C'est plutôt la sous-catégorie C' de C telle que pour tout objet b de la catégorie C' il existe une flèche de a à b"""
def __init__(self,categorie,objet):
CategorieFSous.__init__(self,DiagrammeIdentite(categorie),objet)
def __new__(cls,categorie,objet):
if objet not in categorie.objets:
categorie.transformer_graphviz(complet=False)
raise Exception("Incohérence CategorieSous : objet "+str(objet)+" pas dans la categorie.")
result = copy(categorie)
for obj in categorie.objets:
if len(categorie.enumerer_composees_sans_cycle(objet,obj)) == 0:
result.supprimer_objet(obj)
return result
# def __new__(cls,categorie,objet):
# if objet not in categorie.objets:
# categorie.transformer_graphviz(complet=False)
# raise Exception("Incohérence CategorieSous : objet "+str(objet)+" pas dans la categorie.")
# result = copy(categorie)
# for obj in categorie.objets:
# if len(categorie.enumerer_composees_sans_cycle(objet,obj)) == 0:
# result.supprimer_objet(obj)
# return result
def main():
import CategorieAleatoire
import random
random.seed(14896488564964)
cat = CategorieAleatoire.CategorieAleaIsomorph()
cat = CategorieAleatoire.CategorieAleaPreOrdre()
cat.transformer_graphviz()
cat.csv_loi_de_composition('lois de composition/loi.csv')
obj = random.choice(cat.objets)
print(obj)
......
......@@ -276,63 +276,7 @@ class CompositionClustersActifs(ClusterActif):
raise Exception("Composition de clusters impossible : "+clusters.__repr__())
instance = ClusterActif(clusters[0].source,clusters[-1].cible)
return instance
class ProtoClusterPerspectifs(ClusterAbstrait):
"""Seules les contraintes sur les perspectives sont prises en compte pour le cluster perspectif"""
def __init__(self, foncteur1, foncteur2, composantes):
ClusterAbstrait.__init__(self,foncteur1, foncteur2, composantes)
if TOUJOURS_VERIFIER_COHERENCE:
ProtoClusterPerspectifs.verifier_coherence(self)
def verifier_coherence(self):
if self.foncteur1.cat_cible != self.foncteur2.cat_cible:
raise Exception("Incoherence ProtoClusterPerspectifs : les deux foncteurs n'ont pas la meme image.")
impl1, impl2 = [self.foncteur1.categorie_image(),self.foncteur2.categorie_image()]
for composante in self.composantes:
if composante.source not in impl1.objets:
raise Exception("Incoherence ProtoClusterActif : la composante "+str(composante)+" ne prend pas sa source dans l'image de F1")
if composante.cible not in impl2.objets:
raise Exception("Incoherence ProtoClusterActif : la composante "+str(composante)+" ne prend pas sa cible dans l'image de F2")
# contrainte 1) au moins une flèche part de chacun des objets de D1
for d in self.foncteur1.cat_source.objets:
for composante in self.composantes:
if composante.source == self.foncteur1(d):
break
else:
raise Exception("Incoherence ProtoClusterActif : l'objet "+str(self.foncteur1(d))+" de D1 n'a pas de d'image par le cluster")
# contrainte 2) les composantes qui sortent d'un objet d de D1 mènent à des objets e de D2 reliés par un zig zag dans la catégorie sous d
for d in self.foncteur1.cat_source.objets:
E_e = [] #les images des composantes
for composante in self.composantes:
if composante.source == self.foncteur1(d):
E_e += [composante.cible]
cat_sous = CategorieSous(self.categorie, self.foncteur1(d))
cat_cc = CategorieComposantesConnexes(cat_sous)
# on vérifie que tous les E(e) sont isomorphes dans la catégorie des composantes connexes de la catégorie sous D(d)
for e in E_e[1:]:
if cat_cc.existe_composee(E_e[0],e) == None:
raise Exception("Incoherence ProtoClusterActif : l'objet "+str(E_e[0])+" n'est pas dans la même composante connexe que "+str(e))
# contrainte 3) eog = g'
for composante in self.composantes:
for e in self.foncteur2.cat_source.objets:
if self.foncteur2(e) == composante.cible:
for eps in self.foncteur2.cat_source.morph_sortants[e]:
composee = self.categorie.Composee(composante,self.foncteur2(eps))
if composee not in self.composantes:
raise Exception("Incoherence ProtoClusterActif : la composee de la composante "+str(composante)+" avec la fleche "+str(self.foncteur2(eps))+" de D2 n'est pas dans le cluster")
# contrainte 4) god = g'
for composante in self.composantes:
for d in self.foncteur1.cat_source.objets:
if self.foncteur1(d) == composante.source:
for delta in self.foncteur1.cat_source.morph_entrants[d]:
composee = self.categorie.Composee(self.foncteur1(delta),composante)
if composee not in self.composantes:
raise Exception("Incoherence ProtoClusterActif : la composee de la fleche "+str(self.foncteur1(delta))+" de D1 avec la composante "+str(composante)+" n'est pas dans le cluster")
def main():
......
......@@ -41,7 +41,11 @@ class Foncteur(Morphisme.Morphisme):
return Diagramme.Diagramme(self.cat_source,self.cat_cible,self.app_objets,self.app_morph)
def verifier_coherence(self):
Foncteur.transformer_graphviz(self,"graphviz/ErreurFoncteur")
# Foncteur.transformer_graphviz(self,"graphviz/ErreurFoncteur")
for obj in self.app_objets:
if obj in self.app_morph:
raise Exception("Incoherence foncteur : "+str(obj)+" est a la fois un objet et un morphisme de la categorie source")
for o in self.cat_source.objets:
if o not in self.app_objets:
......
......@@ -30,7 +30,7 @@ class Morphisme:
return str(self.representant)+' : '+str(self.source)+" -> "+str(self.cible)
def __repr__(self):
return self.pretty_print()+","+super().__repr__().split('object at ')[-1].split('>')[0]
return self.pretty_print()#+","+super().__repr__().split('object at ')[-1].split('>')[0]
def __len__(self):
return len(self.composee)
......
Supports Markdown
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