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

Possibilité d'identifier les identités dans les catégories aléatoires

parent 0b3097fb
......@@ -23,7 +23,7 @@ class GrapheCompositionAleatoire(GC):
GrapheCompositionAleatoire peut être abrégé en GCA"""
_id = 0
def __init__(self, nb_fleches:Union[int,None] = None, nb_tentatives_complexification_loi_de_compo:Union[int,None] = None, nb_tentatives_correction_composition:Union[Callable,int,None] = None, nom:Union[str,None] = None):
def __init__(self, nb_fleches:Union[int,None] = None, nb_tentatives_complexification_loi_de_compo:Union[int,None] = None, nb_tentatives_correction_composition:Union[Callable,int,None] = None, proba_identifier_identites:int = 0.2, nom:Union[str,None] = None):
"""`nb_fleches` est le nombre de flèches élémentaires dans la catégorie aléatoire.
`nb_tentatives_complexification_loi_de_compo` détermine à quel point la loi de composition sera complexifiée,
si le nombre est faible on obtient une catégorie où les flèches sont isolées.
......@@ -31,7 +31,9 @@ class GrapheCompositionAleatoire(GC):
`nb_tentatives_correction_composition` détermine à quel point on pousse loin la recherche de correction de la loi de composition par
rapport à la contrainte de composition.
Si le nombre est faible, on aura quasiment aucun cycle, si le nombre est grand, la création de cycles et favorisée mais le temps de calcul est plus long.
Par défaut, un nombre est tiré au hasard à chaque fois entre 3 et 6."""
Par défaut, un nombre est tiré au hasard à chaque fois entre 3 et 6.
`proba_identifier_identites` donne la probabilité que la tentative de complexification soit une identification d'identités,
plus la probabilité est grande et plus les catégories seront connexes."""
GrapheCompositionAleatoire._id += 1
self._id = GrapheCompositionAleatoire._id
if nom == None:
......@@ -101,19 +103,29 @@ class GrapheCompositionAleatoire(GC):
def fleches(self) -> set:
assert(set(self.source.keys()) == set(self.cible.keys()))
return set(self.source.keys())
@property
def identites(self) -> set:
return {f for f in self.source if f >= nb_fleches}
def tentative_complexification(loi:LoiDeComposition,i:int,j:int,nb_tentatives:int = 3) -> Union[LoiDeComposition,None]:
"""Tente de complexifier la loi de composition en définissant la composition j o i.
Si i est une identité, alors on tente d'identifier i à une autre identité.
Renvoie une nouvelle loi de composition si succès, None sinon."""
nouvelle_loi = copy.deepcopy(loi)
if nouvelle_loi.table[(i,j)] != None:
return None
ij = random.choice(list(nouvelle_loi.fleches))
nouvelle_loi.table[(i,j)] = ij
nouvelle_loi.identifier_identites(nouvelle_loi.source[i],nouvelle_loi.source[ij])
nouvelle_loi.identifier_identites(nouvelle_loi.cible[j],nouvelle_loi.cible[ij])
nouvelle_loi.identifier_identites(nouvelle_loi.cible[i],nouvelle_loi.source[j])
if i < nb_fleches:
# définition d'une composée
if nouvelle_loi.table[(i,j)] != None:
return None
ij = random.choice(list(nouvelle_loi.fleches))
nouvelle_loi.table[(i,j)] = ij
nouvelle_loi.identifier_identites(nouvelle_loi.source[i],nouvelle_loi.source[ij])
nouvelle_loi.identifier_identites(nouvelle_loi.cible[j],nouvelle_loi.cible[ij])
nouvelle_loi.identifier_identites(nouvelle_loi.cible[i],nouvelle_loi.source[j])
else:
# identification d'identités
ij = random.choice(list(nouvelle_loi.identites))
nouvelle_loi.identifier_identites(i,ij)
while True:
for a,b,c in itertools.product(range(nb_fleches),repeat=3):
ab = nouvelle_loi.table[(a,b)]
......@@ -171,7 +183,12 @@ class GrapheCompositionAleatoire(GC):
else:
iterator = range(nb_tentatives_complexification_loi_de_compo)
for tentative in iterator:
i,j = random.randint(0,nb_fleches-1),random.randint(0,nb_fleches-1)
if random.random() < proba_identifier_identites:
# ici on identifie deux identités plutôt que de définir une composée
i = j = random.choice(list(loi.identites))
else:
# ici on définit une composée
i,j = random.randint(0,nb_fleches-1),random.randint(0,nb_fleches-1)
if nb_tentatives_correction_composition == None:
loi2 = tentative_complexification(loi,i,j,random.randint(3,6))
elif type(nb_tentatives_correction_composition) is int:
......@@ -224,7 +241,7 @@ GCA = GrapheCompositionAleatoire
def test_GrapheCompositionAleatoire():
random.seed(1)
for i in range(20):
for i in range(10):
GCA = GrapheCompositionAleatoire()
GCA.transformer_graphviz()
GCA.loi_de_composition_to_csv('lois de composition/loi_de_compo.csv')
......@@ -364,8 +381,8 @@ class FoncteurAleatoire(Foncteur):
if categorie_cible == None:
categorie_cible = GrapheCompositionAleatoire()
categorie_indexante.transformer_graphviz()
categorie_cible.transformer_graphviz()
# categorie_indexante.transformer_graphviz()
# categorie_cible.transformer_graphviz()
app_obj = dict()
app_morph = dict()
......@@ -445,6 +462,6 @@ def test_FoncteurAleatoire():
if __name__ == '__main__':
# test_GrapheCompositionAleatoire()
test_GrapheCompositionAleatoire()
# test_MonoideGC()
test_FoncteurAleatoire()
\ No newline at end of file
# test_FoncteurAleatoire()
\ No newline at end of file
......@@ -9,16 +9,6 @@ from copy import copy
from TransformationNaturelle import TransfoNat
from typing import *
cat_i = GC(set("ABC"))
f_i,g_i = [MGC('B','A','f'),MGC('B','C','g')]
cat_i |= {f_i,g_i}
cat = GC(set("ABCDE"))
f,g,h,i,j,k,l,m = [MGC('B','A','f'),MGC('B','C','g'),MGC('A','D','h'),MGC('B','D','i'),MGC('C','D','j'),MGC('A','E','k'),MGC('B','E','l'),MGC('C','E','m')]
cat |= {f,g,h,i,j,k,l,m}
diag = Diagramme(cat_i,cat,{'A':'A','B':'B','C':'C'},{f_i:f,g_i:g})
def modification(gc: GC, option_ajout:Tuple[Sequence[Any],Sequence[Morphisme]] = (set(),set()), option_elimination:Sequence[Diagramme] = set(), option_complex_agissante:Sequence[Diagramme] = set(), option_complex_classifiante:Sequence[Diagramme] = set()) -> Tuple[GC,Foncteur]:
nouveau_gc = copy(gc)
fonct = Foncteur(gc,nouveau_gc,{o:o for o in gc.objets},{m:m for m in gc[gc.objets,gc.objets]})
......@@ -27,9 +17,14 @@ def modification(gc: GC, option_ajout:Tuple[Sequence[Any],Sequence[Morphisme]] =
nouveau_gc |= set(nouvelles_fleches)
nouveau_gc -= set(option_elimination)
while True:
print("a")
nouveau_gc.transformer_graphviz()
for diag in option_complex_agissante:
c_a = ChampActif(fonct@diag)
c_a.transformer_graphviz()
colimites = c_a.objets_colimites()
for cocone in c_a.objets:
Cocone(cocone).transformer_graphviz()
if len(colimites) == 0:
# S'il n'y avait pas de colimite, on la créé
nouvel_objet = "Colimite de "+str(diag)
......@@ -42,9 +37,17 @@ def modification(gc: GC, option_ajout:Tuple[Sequence[Any],Sequence[Morphisme]] =
jambe = MGC(diag(i),nouvel_objet)
dico_index_jambe[i] = jambe
nouveau_gc |= {jambe}
for fleche_i in diag.source[diag.source.objets, diag.source.objets]:
for obj in diag.source.objets:
for fleche in nouveau_gc({diag(obj)},{nouvel_objet}):
if dico_index_jambe[obj] != fleche:
MGC.identifier_morphismes(fleche,dico_index_jambe[obj])
for fleche_i in diag.source(diag.source.objets, diag.source.objets):
if dico_index_jambe[fleche_i.source] != dico_index_jambe[fleche_i.cible]@diag(fleche_i):
MGC.identifier_morphismes(dico_index_jambe[fleche_i.cible]@diag(fleche_i),dico_index_jambe[fleche_i.source])
if dico_index_jambe[fleche_i.cible]@diag(fleche_i) in nouveau_gc[nouveau_gc.objets,nouveau_gc.objets]:
nouveau_gc -= {dico_index_jambe[fleche_i.cible]@diag(fleche_i)}
else:
MGC.identifier_morphismes(dico_index_jambe[fleche_i.cible]@diag(fleche_i),dico_index_jambe[fleche_i.source])
#ajouter les flèches vers les autres cocônes
for cocone in c_a.objets:
cocone = Cocone(cocone)
......@@ -69,9 +72,17 @@ def modification(gc: GC, option_ajout:Tuple[Sequence[Any],Sequence[Morphisme]] =
jambe = MGC(nouvel_objet,diag(i))
dico_index_jambe[i] = jambe
nouveau_gc |= {jambe}
for fleche_i in diag.source[diag.source.objets, diag.source.objets]:
for obj in diag.source.objets:
for fleche in nouveau_gc({nouvel_objet},{diag(obj)}):
if dico_index_jambe[obj] != fleche:
MGC.identifier_morphismes(fleche,dico_index_jambe[obj])
for fleche_i in diag.source(diag.source.objets, diag.source.objets):
if dico_index_jambe[fleche_i.cible] != diag(fleche_i)@dico_index_jambe[fleche_i.source]:
MGC.identifier_morphismes(diag(fleche_i)@dico_index_jambe[fleche_i.source],dico_index_jambe[fleche_i.cible])
if diag(fleche_i)@dico_index_jambe[fleche_i.source] in nouveau_gc[nouveau_gc.objets,nouveau_gc.objets]:
nouveau_gc -= {diag(fleche_i)@dico_index_jambe[fleche_i.source]}
else:
MGC.identifier_morphismes(diag(fleche_i)@dico_index_jambe[fleche_i.source],dico_index_jambe[fleche_i.cible])
#ajouter les flèches depuis les autres cônes
for cone in c_p.objets:
cone = Cone(cone)
......@@ -86,21 +97,60 @@ def modification(gc: GC, option_ajout:Tuple[Sequence[Any],Sequence[Morphisme]] =
return nouveau_gc,fonct
diag2 = DiagrammeIdentite(cat)
diag2.faire_commuter()
def test_Complexification():
cat_i = GC(set("ABC"))
f_i,g_i = [MGC('B','A','f'),MGC('B','C','g')]
cat_i |= {f_i,g_i}
cat = GC(set("ABCDE"))
f,g,h,i,j,k,l,m = [MGC('B','A','f'),MGC('B','C','g'),MGC('A','D','h'),MGC('B','D','i'),MGC('C','D','j'),MGC('A','E','k'),MGC('B','E','l'),MGC('C','E','m')]
cat |= {f,g,h,i,j,k,l,m}
diag = Diagramme(cat_i,cat,{'A':'A','B':'B','C':'C'},{f_i:f,g_i:g})
diag.transformer_graphviz()
cat.transformer_graphviz()
diag2 = DiagrammeIdentite(cat)
diag2.faire_commuter()
ChampActif(diag).transformer_graphviz()
cat2,fonct = modification(cat,(set(),set()),{},{diag},{diag})
cat2.transformer_graphviz()
fonct.transformer_graphviz()
diag.transformer_graphviz()
cat.transformer_graphviz()
diag = fonct@diag
diag.transformer_graphviz()
ChampActif(diag).transformer_graphviz()
for cone in ChampActif(diag).objets_colimites():
Cocone(cone).transformer_graphviz()
ChampActif(diag).transformer_graphviz()
cat2,fonct = modification(cat,(set(),set()),{},{diag},{diag})
cat2.transformer_graphviz()
fonct.transformer_graphviz()
diag = fonct@diag
diag.transformer_graphviz()
ChampActif(diag).transformer_graphviz()
for cone in ChampActif(diag).objets_colimites():
Cocone(cone).transformer_graphviz()
def test_Complexification2():
import random
from CategorieAleatoire import GCA, FoncteurAleatoire
# random.seed(123)
random.seed(12345)
cat = GC(set("ABC"))
f,g = [MGC('B','A','f'),MGC('B','C','g')]
cat |= {f,g}
for i in range(20):
c_i = GCA(random.randint(1,5),random.randint(0,5))
# c_i = GCA(random.randint(1,5),random.randint(0,10))
c_i.transformer_graphviz()
diag = FoncteurAleatoire(c_i,cat)
diag.as_diagram().transformer_graphviz()
diag.transformer_graphviz()
cat2,fonct = modification(cat,(set(),set()),{},{diag},{diag})
cat2.transformer_graphviz()
fonct.transformer_graphviz()
cat=cat2
if __name__ == '__main__':
# test_Complexification()
test_Complexification2()
\ No newline at end of file
......@@ -21,6 +21,8 @@ class MorphismeGrapheDeComposition(Morphisme):
`morph1` ne doit pas être élémentaire.
Cette fonction statique modifie la loi de composition de la classe `MorphismeGrapheDeComposition`.
Les morphismes seront identifiés indépendamment des catégories auxquelles ils appartiennent."""
if len(morph1.__chemin) <= 1:
print("Warning : identification d'un morphisme élémentaire : "+str(morph1)+" identifie a "+str(morph2))
MorphismeGrapheDeComposition.loi_de_composition[morph1.__chemin] = morph2.__chemin
MorphismeGrapheDeComposition.verifier_coherence()
......
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