CategorieProhomologue.py 5.59 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
from Categorie import Categorie
from Foncteur import Foncteur
from CatFinies import CatFinies
from EnsFinis import EnsFinis,Application
from ChampPerceptif import ChampPerceptif
from collections import defaultdict
import itertools

class FoncteurOubli(Foncteur):
    """Foncteur d'oubli du champ perceptif.
    Associe à chaque cône sont apex et à chaque flèche entre cône la flèche d'où elle vient."""
    
    def __init__(self, champ_perceptif:ChampPerceptif):
        univers = champ_perceptif.foncteur_diagonal.source
        Foncteur.__init__(self, champ_perceptif, univers, {obj:obj.e for obj in abs(champ_perceptif)},
        {f:f.k for f in champ_perceptif(abs(champ_perceptif),abs(champ_perceptif))})
       
class CategorieProhomologue(CatFinies):
    """Catégorie dont les objets sont des champs perceptifs et les morphismes sont des foncteurs qui commutent avec le foncteur d'oubli."""
    
    def verifier_coherence(self):
        CatFinies.verifier_coherence(self)
        for f in self(abs(self),abs(self)):
            fonct_oubli_source = FoncteurOubli(f.source)
            fonct_oubli_cible = FoncteurOubli(f.cible)
            if fonct_oubli_source != fonct_oubli_cible@f:
                raise Exception("Incoherence CategorieProhomologue : "+str(f)+" ne commute pas avec les foncteurs d'oublis")
    
    def identite(self, objet:ChampPerceptif) -> Foncteur:
        return Foncteur(objet,objet,{o:o for o in abs(objet)},{f:f for f in objet(abs(objet),abs(objet))})
        
    def __call__(self, sources:set, cibles:set) -> set:
        result = set()
        for source in sources:
            for cible in cibles:
                dict_apex_cone_source = defaultdict(frozenset)
                for obj in abs(source):
                    dict_apex_cone_source[obj.e] |= {obj}
                dict_apex_cone_cible = defaultdict(frozenset)
                for obj in abs(cible):
                    dict_apex_cone_cible[obj.e] |= {obj}
                if set(dict_apex_cone_source.keys()) != set(dict_apex_cone_cible.keys()):
                    continue
                applications_objets = set() # applications entre cônes de même apex
                ens_objets = EnsFinis()
                for apex in dict_apex_cone_source:
                    ens_objets |= {dict_apex_cone_source[apex]}
                    ens_objets |= {dict_apex_cone_cible[apex]}
                    applications_objets |= {ens_objets({dict_apex_cone_source[apex]},{dict_apex_cone_cible[apex]})}
                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
                    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:
                            break
                    if len(app_fleche_foncteur[(c,d)]) == 0: #la dernière recherche d'applications à échouée, on passe à l'application objet suivante
                        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())
                        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]:
                                    break
                            else:
                                continue
                            break
                        else:
                            result |= {Foncteur(source,cible,app_obj,app_fleches)}
                    
        return result
        
def test_FoncteurOubli():
    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 = ChampPerceptif(d1)
    
    foncteur_oubli = FoncteurOubli(c_p)
    foncteur_oubli.transformer_graphviz()
    
def test_CategorieProhomologue():
    from GrapheDeComposition import GC,MGC
    from Diagramme import Fleche,DiagrammeIdentite
    
    gc = GC()
    gc |= set("ABCDEFGH")
    f,g,h,i,j,k,l,m,n = [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'),MGC('F','G','m'),MGC('F','H','n')]
    gc |= {f,g,h,i,j,k,l,m,n}
    
    diag_identite = DiagrammeIdentite(gc)
    diag_identite.faire_commuter()
    
    d1 = Fleche(gc,m)
    c_p1 = ChampPerceptif(d1)
    d2 = Fleche(gc,n)
    c_p2 = ChampPerceptif(d2)
    
    cph = CategorieProhomologue({c_p1,c_p2})
    cph.transformer_graphviz()
    
    f,g = cph.isomorphismes(c_p1,c_p2).pop()
    f.transformer_graphviz()
    g.transformer_graphviz()
    
if __name__ == '__main__':
    test_FoncteurOubli()
    test_CategorieProhomologue()