ChampActif fonctionnel

ChampActif.py

+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

ChampPerceptif.py

-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

Diagramme.py

@@ -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):
         """

TransformationNaturelle.py

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