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

ChampActif fonctionnel

parent c98d3bad
from CommaCategorie import CommaCategorie
from TransformationNaturelle import CatTransfoNat,TransfoNat
from Foncteur import Foncteur
from Diagramme import DiagrammeConstant,DiagrammeObjets
class ChampActif(CommaCategorie):
"""Le champ actif d'un diagramme(ou foncteur) D:P->Q est défini comme étant la comma-catégorie (D|Δ)
(cf. https://en.wikipedia.org/wiki/Cone_(category_theory)#Equivalent_formulations)
Un objet (Id,C,A) du champ actif nous donne un cocône C de nadir A sur le diagramme D.
Δ:Q -> (P->Q) est un foncteur dans une catégorie infinie, on ne s'intéresse qu'aux diagrammes constants Δq : P->Q, _|->q,_|->1q avec q \in Q
et au diagramme D.
En ne s'intéressant qu'à ces diagrammes, on obtient quand même tous les cocônes sur D.
"""
def __init__(self, diagramme:Foncteur, nom:str = None):
P = diagramme.source
Q = diagramme.cible
self.categorie_diagrammes = CatTransfoNat({DiagrammeConstant(P,Q,o) for o in Q.objets},
"Categorie de diagrammes du champ actif de "+str(diagramme))
self.categorie_diagrammes |= {diagramme}
self.foncteur_diagonal = Foncteur(Q,self.categorie_diagrammes,{o:DiagrammeConstant(P,Q,o) for o in Q.objets},
{f: TransfoNat(DiagrammeConstant(P,Q,f.source),DiagrammeConstant(P,Q,f.cible),{p:f for p in P.objets}) for f in Q(abs(Q),abs(Q))})
## on associe à chaque objet son diagramme constant et à chaque flèche F:a->b la transformation naturelle qui va de Δa à Δb
self.foncteur_vers_D = DiagrammeObjets(self.categorie_diagrammes,{diagramme})
CommaCategorie.__init__(self,self.foncteur_vers_D,self.foncteur_diagonal, "Champ actif de "+str(diagramme) if nom == None else nom)
def cocones(self,nadirs:set) -> set:
"""`nadirs` est un ensemble d'objets de Q
Cette fonction renvoie l'ensemble tous les cocônes de nadir un objets d'`nadirs`.
Un cocône est une interaction de D vers le nadir."""
return {obj.f for obj in self.objets for nadir in nadirs if obj.d == nadir}
def test_ChampActif():
from GrapheDeComposition import GC,MGC
from Diagramme import Triangle,DiagrammeIdentite
gc = GC()
gc |= set("ABCDEF")
f,g,h,i,j,k,l = [MGC('A','B','f'),MGC('B','C','g'),MGC('D','E','h'),MGC('E','F','i'),MGC('A','D','j'),MGC('B','E','k'),MGC('C','F','l')]
gc |= {f,g,h,i,j,k,l}
diag_identite = DiagrammeIdentite(gc)
diag_identite.faire_commuter()
d1 = Triangle(gc,"DEF",[h,i,i@h])
c_p = ChampActif(d1)
for cocone in c_p.cocones(gc.objets):
cocone.transformer_graphviz()
c_p.transformer_graphviz()
if __name__ == '__main__':
test_ChampActif()
\ No newline at end of file
from CommaCategorie import CommaCategorie
from CommaCategorie import CommaCategorie, CategorieSur
from TransformationNaturelle import CatTransfoNat,TransfoNat
from Foncteur import Foncteur
from Diagramme import DiagrammeConstant,DiagrammeObjets
......@@ -12,7 +12,7 @@ class ChampPerceptif(CommaCategorie):
En ne s'intéressant qu'à ces diagrammes, on obtient quand même tous les cônes sur D.
"""
def __init__(self, diagramme:Foncteur):
def __init__(self, diagramme:Foncteur, nom:str = None):
P = diagramme.source
Q = diagramme.cible
self.categorie_diagrammes = CatTransfoNat({DiagrammeConstant(P,Q,o) for o in Q.objets},
......@@ -25,12 +25,14 @@ class ChampPerceptif(CommaCategorie):
self.foncteur_vers_D = DiagrammeObjets(self.categorie_diagrammes,{diagramme})
CommaCategorie.__init__(self,self.foncteur_diagonal,self.foncteur_vers_D)
CommaCategorie.__init__(self,self.foncteur_diagonal,self.foncteur_vers_D, "Champ perceptif de "+str(diagramme) if nom == None else nom)
def cones(self,apices:set) -> set:
"""`apices` est un ensemble d'objets de Q
Cette fonction renvoie l'ensemble tous les cônes d'apex un objets d'`apices`."""
Cette fonction renvoie l'ensemble tous les cônes d'apex un objets d'`apices`.
Un cône est une interaction de l'apex vers D."""
return {obj.f for obj in self.objets for apex in apices if obj.e == apex}
def test_ChampPerceptif():
from GrapheDeComposition import GC,MGC
......
......@@ -18,7 +18,7 @@ class Diagramme(Foncteur):
def __init__(self, categorie_indexante:Categorie, categorie_indexee:Categorie,
application_objets:dict, application_morphismes:dict, representant:any = None):
Foncteur.__init__(self,categorie_indexante,categorie_indexee, application_objets,
application_morphismes,representant=representant+' '+str(self._id) if representant != None else "Diagramme "+str(self._id))
application_morphismes,representant=representant if representant != None else "Diagramme "+str(self._id))
def faire_commuter(self):
"""
......
......@@ -113,22 +113,28 @@ class CategorieTransformationsNaturelles(Categorie):
Une flèche de cette catégorie est une transformation naturelle entre deux diagrammes.
"""
# cache = dict() # (source,cible) : {TransfoNat} permet de mettre en cache les transformations naturelles de source vers cible lors de l'appel de __call__
def identite(self, diag:Diagramme) -> TransfoNat:
return TransfoNat(diag,diag,{o:diag.cible.identite(diag(o)) for o in diag.source.objets})
def __call__(self, source:set, cible:set) -> set:
result = set()
if len(source) > 0:
C = list(source)[0].source
D = list(source)[0].cible
J = list(source)[0].source
C = list(source)[0].cible
for a in source:
for b in cible:
# on cherche toutes les transformations naturelles du diagramme a:C->D vers le diagramme b:C->D
obj_index = C.objets
fleches_arrivee = frozenset(D(abs(D),abs(D)))
# if (a,b) in CategorieTransformationsNaturelles.cache:
# return CategorieTransformationsNaturelles.cache[(a,b)]
# CategorieTransformationsNaturelles.cache[(a,b)] = set()
# on cherche toutes les transformations naturelles du diagramme a:J->C vers le diagramme b:J->C
obj_index = J.objets
fleches_arrivee = frozenset(C({a(o) for o in set(J.objets)},{b(o) for o in set(J.objets)})) # flèches de l'image de a vers l'image de b
ens = EnsFinis({obj_index,fleches_arrivee})
for app in ens({obj_index},{fleches_arrivee}):
for fleche_index in C(abs(C),abs(C)):
for fleche_index in J(abs(J),abs(J)):
if app(fleche_index.source).cible != b(fleche_index).source:
break
if a(fleche_index).cible != app(fleche_index.cible).source:
......@@ -137,6 +143,7 @@ class CategorieTransformationsNaturelles(Categorie):
break
else:
result |= {TransfoNat(a,b,app.as_dict())}
# CategorieTransformationsNaturelles.cache[(a,b)] |= {TransfoNat(a,b,app.as_dict())}
return result
CatTransfoNat = CategorieTransformationsNaturelles
......
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