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

Catégorie Catégories composantes connexes finie, abandon de la factorisation...

Catégorie Catégories composantes connexes finie, abandon de la factorisation des catégories pour calculer tous les foncteurs -> il y en a trop, je pars plutôt sur une construction greedy du foncteur aléatoire
parent 7e0b8944
......@@ -21,7 +21,9 @@ from graphviz import Digraph
class GrapheCompositionAleatoire(GC):
"""Construit un graphe de composition aléatoire.
GrapheCompositionAleatoire peut être abrégé en GCA"""
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:str = "Catégorie Aléatoire"):
_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):
"""`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.
......@@ -30,6 +32,11 @@ class GrapheCompositionAleatoire(GC):
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."""
GrapheCompositionAleatoire._id += 1
self._id = GrapheCompositionAleatoire._id
if nom == None:
nom = "Catégorie aléatoire "+str(self._id)
if nb_fleches == None:
nb_fleches = random.randint(1,20)
......
from Categorie import Categorie
from Foncteur import Foncteur
from CategorieQuotient import CategorieQuotient
from EnsFinis import EnsFinis, Application
from Morphisme import Morphisme
import itertools
from typing import *
class CategorieComposantesConnexes(CategorieQuotient):
"""Catégorie quotientée par la relation d'équivalence sur les objets suivante :
x ~ y si il existe f: x -> y ou il existe f: y -> x."""
......@@ -36,6 +40,64 @@ def test_CategorieComposantesConnexes():
c_a = CategorieComposantesConnexes(c)
c_a.transformer_graphviz()
c_a.fonct_surjection.transformer_graphviz()
class CategorieCatComposantesConnexes(Categorie):
"""Catégorie des catégories composantes connexes.
Les foncteurs sont simplement des applications d'objets."""
def __init__(self,objets:set=set(),nom:str="CatCatComposantesConnexes"):
Categorie.__init__(self,objets,nom)
def __call__(self, sources:set, cibles:set) -> Generator[Application,None,None]:
'''/!\ __call__ n'appelle pas __getitem__ /!\ '''
ens_finis = EnsFinis()
for source in sources:
for cible in cibles:
ens_finis |= {source.objets,cible.objets}
for m in ens_finis.__call__({source.objets},{cible.objets}):
m = m.as_dict()
yield Foncteur(source,cible,m,{source.identite(obj):cible.identite(m[obj]) for obj in m})
def __getitem__(self, couple_sources_cibles:tuple) -> Generator[Application,None,None]:
'''/!\ __call__ n'appelle pas __getitem__ /!\ '''
sources,cibles = couple_sources_cibles
ens_finis = EnsFinis()
for source in sources:
for cible in cibles:
ens_finis |= {source.objets,cible.objets}
for m in ens_finis.__getitem__(({source.objets},{cible.objets})):
m = m.as_dict()
yield Foncteur(source,cible,m,{source.identite(obj):cible.identite(m[obj]) for obj in m})
def test_CategorieCatComposantesConnexes():
from CategorieAleatoire import GrapheCompositionAleatoire
import random
random.seed(3)
C = CategorieCatComposantesConnexes()
c = GrapheCompositionAleatoire()
c.transformer_graphviz()
c_a = CategorieComposantesConnexes(c)
c_a.transformer_graphviz()
C |= {c_a}
c = GrapheCompositionAleatoire()
c.transformer_graphviz()
c_a2 = CategorieComposantesConnexes(c)
c_a2.transformer_graphviz()
C |= {c_a2}
print(len(list(C({c_a},{c_a2}))))
print(len(list(C({c_a2},{c_a}))))
C.transformer_graphviz()
if __name__ == '__main__':
test_CategorieComposantesConnexes()
\ No newline at end of file
# test_CategorieComposantesConnexes()
test_CategorieCatComposantesConnexes()
\ No newline at end of file
from Categorie import Categorie
from CategorieQuotient import CategorieQuotient
class CategorieFactorisee(Categorie):
"""Classe abstraite.
Un catégorie factorisée est une catégorie de catégories tel que le calcul des foncteurs
entre deux catégories est factorisée en passant par une catégorie quotient.
Pour calculer les foncteurs entre C et C', on calcule d'abord les foncteurs F entre
C/R et C'/R puis on calcule tous les foncteurs F_i entre les sous-catégories classes d'équivalence de C et C' que l'on note
C[i] et C'[i] tel que F(C[i]) = C'[i].
On fait ensuite le produit cartésien entre tous ces F_i pour chaque F. On a alors tous les foncteurs de C à C'.
Une catégorie de catégories quotients pour calculer les foncteurs entre catégories quotientées,
une catégorie de catégories classes d'équivalence pour calculer les foncteurs entre classes d'équivalence."""
\ No newline at end of file
......@@ -68,9 +68,16 @@ entre deux classes d'équivalence s'il existe au moins une flèche d'un objet d'
- ce graphe est acyclique.
- un foncteur doit préserver la structure de graphe acyclique -> (faire la catégorie des graphes acycliques ?)
Catégorie aléatoire : laisser la possibilité que la composition donne l'identité.
-1 donne les morphismes eux même lorsque composés (identité)
si source et target dans même classes d'équivalence, alors ajouter l'outcome -1
La catégorie squelettique n'est pas une catégorie squelettique, les cycles ne sont pas forcément des isomorphismes.
Trouver un autre nom pour ces catégories
Faire un argument par défaut pour call et getitem pour qu'on ai besoin de rien mettre pour avoir toutes les flèches
Modifier Morphisme pour que source, cible et is_identite soient read-only
Factorisation inutile -> déjà trop de foncteurs pour cc, utiliser ça plus tard pour les foncteurs bijectifs.
Retirer tous les if TOUJOURS_VERIFIER_COHERENCE: verifier_coherence dans les classes filles, les méthodes sont de toute manière appelées par catégorie.
On part plutôt sur une construction greedy aléatoire du foncteur alea
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