Commit 687e20a9 authored by Guillaume Sabbagh's avatar Guillaume Sabbagh
Browse files

Scission ProtoClusters et Clusters

parent 0ac440f2
......@@ -4,7 +4,7 @@ from Foncteur import Foncteur
from CommaCategorie import ObjetCommaCategorie,CategorieFSous
from CategoriePreordreZigZag import CatPZigZag
from Interaction import CategorieInteractions
from config import *
import config
from copy import copy
class ProtoClusterActif(Interaction):
......@@ -57,8 +57,7 @@ class ProtoClusterActif(Interaction):
def __init__(self, D1:Foncteur, D2:Foncteur, composantes:set, nom:str = None):
"""composantes est un ensemble d'objets de la comma-catégorie (D1|D2)"""
Interaction.__init__(self,D1, D2, composantes,nom)
self.__categorie_cluster = None
if TOUJOURS_VERIFIER_COHERENCE:
if config.TOUJOURS_VERIFIER_COHERENCE:
ProtoClusterActif.verifier_coherence(self)
def verifier_coherence(self):
......@@ -66,32 +65,6 @@ class ProtoClusterActif(Interaction):
coherence,exception_levee = ProtoClusterActif.verifier_struct(self)
if not coherence:
raise exception_levee
def __matmul__(self,other:'ProtoClusterActif') -> 'ProtoClusterActif':
"""La composition de deux clusters G1 et G2 est le cluster engendré par la composition de G1 et G2 vus comme des interactions."""
import config
if self.__categorie_cluster == None:
backup = config.TOUJOURS_VERIFIER_COHERENCE
config.TOUJOURS_VERIFIER_COHERENCE = 0 # on empêche la vérification de la cohérence de CategorieClusters qui ferait une boucle infinie
self.__categorie_cluster = CategorieClusters(self.source.cible,{self.cible},"Catégorie cluster de "+str(self))
config.TOUJOURS_VERIFIER_COHERENCE = backup
composition_interaction = Interaction.__matmul__(self,other) # on calcule la composition des interactions
#on doit trouver le cluster engendré par la composition_interaction
self.__categorie_cluster |= {other.source}
clusters_candidats = self.__categorie_cluster({other.source},{self.cible})
clusters_finaux = set()
for cluster in clusters_candidats:
for obj_comma in composition_interaction:
if obj_comma not in cluster:
break
else:
clusters_finaux |= {cluster}
if len(clusters_finaux) > 1:
raise Exception("Plus d'une composition possible "+str(self)+"o"+str(other)+"\n"+str(clusters_finaux))
if len(clusters_finaux) == 0:
raise Exception("Aucune composition trouvee pour "+str(self)+"o"+str(other)+"\n"+str(clusters_candidats))
return ProtoClusterActif(other.source,self.cible,{composante for composante in clusters_finaux.pop()},str(self)+'o'+str(other))
def __lt__(self, other:'ProtoClusterActif') -> bool:
'''G1 < G2 si G1 est inclus strictement dans G2'''
......@@ -121,6 +94,81 @@ class ProtoClusterActif(Interaction):
return False
return True
class ClusterActif(ProtoClusterActif):
"""Un cluster est un proto-cluster maximal."""
def __init__(self,proto_cluster:ProtoClusterActif):
self.__categorie_proto_cluster = None # sert à calculer tous les proto-clusters pour tester la maximalité
ProtoClusterActif.__init__(self,proto_cluster.source,proto_cluster.cible,{compo for compo in proto_cluster},str(proto_cluster))
if config.TOUJOURS_VERIFIER_COHERENCE:
self.verifier_coherence()
def __get_categorie_proto_cluster(self):
if self.__categorie_proto_cluster == None:
backup = config.TOUJOURS_VERIFIER_COHERENCE
config.TOUJOURS_VERIFIER_COHERENCE = 0 # on empêche la vérification de la cohérence de CategorieClusters qui ferait une boucle infinie
self.__categorie_proto_cluster = CategorieProtoClusters(self.source.cible,{self.source,self.cible},"Catégorie cluster de "+str(self))
config.TOUJOURS_VERIFIER_COHERENCE = backup
return self.__categorie_proto_cluster
def verifier_coherence(self):
proto_clusters = self.__get_categorie_proto_cluster()({self.source},{self.cible})
for proto_cluster in proto_clusters:
if proto_cluster > self:
raise Exception("Incoherence ClusterActif : cluster pas maximal "+str(proto_cluster))
def __matmul__(self,other:'ProtoClusterActif') -> 'ProtoClusterActif':
"""La composition de deux clusters G1 et G2 est le cluster engendré par la composition de G1 et G2 vus comme des interactions."""
composition_interaction = Interaction.__matmul__(self,other) # on calcule la composition des interactions
#on doit trouver le cluster engendré par la composition_interaction
cat_proto = self.__get_categorie_proto_cluster()
cat_proto |= {other.source}
clusters_candidats = cat_proto({other.source},{self.cible})
clusters_finaux = set()
for cluster in clusters_candidats:
for obj_comma in composition_interaction:
if obj_comma not in cluster:
break
else:
for cluster_final in clusters_finaux:
assert(cluster_final != cluster)
if cluster_final < cluster:
clusters_finaux |= {cluster}
clusters_finaux -= {cluster_final}
break
if cluster_final > cluster:
break
else: # ici cluster est incomparable avec tous les clusters finaux
clusters_finaux |= {cluster}
if len(clusters_finaux) > 1:
raise Exception("Plus d'une composition possible "+str(self)+"o"+str(other)+"\n"+str(clusters_finaux))
if len(clusters_finaux) == 0:
raise Exception("Aucune composition trouvee pour "+str(self)+"o"+str(other)+"\n"+str(clusters_candidats))
return ProtoClusterActif(other.source,self.cible,{composante for composante in clusters_finaux.pop()},str(self)+'o'+str(other))
class CategorieProtoClusters(CategorieInteractions):
"""
CategorieProtoClusters est une catégorie d'organisations où les intéractions sont des proto-clusters.
"""
def __init__(self, univers:Categorie ,diagrammes:set = set(), nom:str = None):
"""
CategorieProtoClusters est la catégorie dont les objets sont des diagrammes de cible `univers` et les morphismes sont des proto-clusters.
Par défaut, on considère pour chaque objet O de l'`univers` le diagramme 1_O qui associe à un objet l'objet O.
On retrouve ainsi l'`univers` dans la catégorie des proto-clusters.
`diagrammes` est un ensemble de diagrammes d'intérêts à ajouter à la catégorie.
"""
CategorieInteractions.__init__(self,univers,diagrammes,"Catégorie des diagrammes et clusters sur "+str(univers) if nom == None else nom)
def identite(self,objet:Foncteur) -> ProtoClusterActif:
return ProtoClusterActif(objet,objet,{ObjetCommaCategorie(obj_indexant,objet.cible.identite(objet(obj_indexant)),obj_indexant) for obj_indexant in objet.source.objets})
def __call__(self, sources:set, cibles:set) -> set:
result = set()
for source in sources:
for cible in cibles:
result |= {interact for interact in CategorieInteractions.__call__(self,{source},{cible}) if ProtoClusterActif.verifier_struct(interact)[0]}
return result
class CategorieClusters(CategorieInteractions):
"""
CategorieClusters est une catégorie d'organisations où les intéractions sont des clusters.
......@@ -135,7 +183,7 @@ class CategorieClusters(CategorieInteractions):
"""
CategorieInteractions.__init__(self,univers,diagrammes,"Catégorie des diagrammes et clusters sur "+str(univers) if nom == None else nom)
def identite(self,objet:Foncteur) -> ProtoClusterActif:
def identite(self,objet:Foncteur) -> ClusterActif:
clusters_candidats = self({objet},{objet})
clusters_finaux = set()
for cluster in clusters_candidats:
......@@ -175,7 +223,7 @@ class CategorieClusters(CategorieInteractions):
else:
# ici on n'a jamais break, ce qui signifie que le proto_cluster_candidat était incomparable avec tous les proto_cluster_maximaux
proto_cluster_maximaux |= {proto_cluster_candidat}
result |= set(proto_cluster_maximaux)
result |= {ClusterActif(proto_cluster) for proto_cluster in proto_cluster_maximaux}
return result
......
from Categorie import Categorie
from Foncteur import Foncteur
from Interaction import Interaction,CategorieInteractions
from CommaCategorie import ObjetCommaCategorie,CategorieFSous
from CategoriePreordreZigZag import CatPZigZag
import config
class Perspective(Interaction):
"""Un perspective est une interaction d'un diagramme constant D1 vers un diagramme D2 tel que :
- ses composantes font partie de la même composante connexe de (D1(0)|D2)
- la famille de composantes est maximale."""
\ No newline at end of file
import Categorie,CategorieAleatoire
from Diagramme import *
import CategorieCones,CategorieCocones,CategorieFleurie,CategorieClusters
import Bouquet
import random
import itertools
from Morphisme import Morphisme
import Foncteur
import Cluster
# random.seed(15617)
# cat = CategorieAleatoire.CategorieAleaIsomorph(10,16)
# cat.transformer_graphviz(complet=False)
# cat.transformer_graphviz(complet=True)
# diag1 = Diagramme.DiagrammeAlea(cat,1)
# diag1.transformer_graphviz()
# cat_cones = CategorieCones.CategorieCones(diag1)
# cat_cones.transformer_graphviz(complet=False)
# for lim in cat_cones.limites():
# lim.transformer_graphviz()
# cat_cocones = CategorieCocones.CategorieCocones(diag1)
# cat_cocones.transformer_graphviz(complet=False)
# for lim in cat_cocones.colimites():
# lim.transformer_graphviz()
# diag2 = Diagramme.DiagrammeAlea(cat,1)
# diag2.transformer_graphviz()
# f = diag2.est_prohomologue_a(diag1)
# if f != None:
# f.transformer_graphviz()
# b = Bouquet.Bouquets(diag1,diag2)
# b.transformer_graphviz()
# b = Bouquet.Bouquets(diag2,diag1)
# b.transformer_graphviz()
# cat = Categorie.Categorie()
# cat.ajouter_objets("AB")
# f = Morphisme('A','B','f')
# g = Morphisme('A','B','g')
# cat.ajouter_morphismes([f,g])
# cat.transformer_graphviz()
# diag1 = Diagramme.Fleche(cat,f)
# diag1.transformer_graphviz()
# diag2 = Diagramme.Fleche(cat,g)
# diag2.transformer_graphviz()
# f = diag1.est_prohomologue_a(diag2)
# if f != None:
# f.transformer_graphviz()
# f = diag1.est_homologue_a(diag2)
# if f != None:
# f.transformer_graphviz()
# b = Bouquet.BouquetsPerceptifs(diag1,diag2)
# b.transformer_graphviz()
# b = Bouquet.BouquetsPerceptifs(diag2,diag1)
# b.transformer_graphviz()
# diag1.champ_perceptif().transformer_graphviz()
# diag2.champ_perceptif().transformer_graphviz()
# random.seed(1561741474774747587575775887517)
# cat = CategorieAleatoire.CategorieAlea(7,8)
# cat.transformer_graphviz()
# diag = Diagramme.DiagrammeAlea(cat,3)
# diag.transformer_graphviz()
# cones = CategorieCones.CategorieCones(diag)
# cones.transformer_graphviz()
# cat.ajouter_objets(["S"])
# f,g,h = [Morphisme('S',6,'f'),Morphisme('S',2,'g'),Morphisme('S',4,'h')]
# cat.ajouter_morphismes([f,g,h])
# s1 = Morphisme(3,'S','s1')
# cat.ajouter_morphisme(s1)
# s2 = Morphisme(3,'S','s2')
# cat.ajouter_morphisme(s2)
# cone = cones.objets[0]
# for jambe in cone.jambes.values():
# print(jambe.pretty_print())
# diagramme = Diagramme.Parallele(cat,[3,jambe.cible],[jambe,cat.Composee(s1,eval(input()))])
# diagramme.transformer_graphviz()
# diagramme.faire_commuter()
# cone = cones.objets[1]
# for jambe in cone.jambes.values():
# print(jambe.pretty_print())
# diagramme = Diagramme.Parallele(cat,[3,jambe.cible],[jambe,cat.Composee(s2,eval(input()))])
# diagramme.transformer_graphviz()
# diagramme.faire_commuter()
# diagramme = Diagramme.Chemins(cat,"S",2)
# diagramme.transformer_graphviz()
# diagramme.faire_commuter()
# diagramme = Diagramme.Chemins(cat,"S",6)
# diagramme.transformer_graphviz()
# diagramme.faire_commuter()
# diagramme = Diagramme.Chemins(cat,"S",4)
# diagramme.transformer_graphviz()
# diagramme.faire_commuter()
# cat.transformer_graphviz()
# cones = CategorieCones.CategorieCones(diag)
# cones.transformer_graphviz()
# cat = Categorie.Categorie()
# cat.ajouter_objets("123ABS")
# f,g,h,f1,g1,h1,s,s_,s1,s2,s3 = [Morphisme('1','A','f'),Morphisme('2','A','g'),Morphisme('3','A','h'),Morphisme('1','B','f1'),Morphisme('2','B','g1'),Morphisme('3','B','h1'),Morphisme('S','A','s'),Morphisme('S','B',"s'"),Morphisme('1','S','s1'),Morphisme('2','S','s2'),Morphisme('3','S','s3')]
# cat.ajouter_morphismes([f,g,h,f1,g1,h1,s,s_])
# diagramme = Diagramme.DiagrammeIdentite(cat)
# diagramme.faire_commuter()
# cat.transformer_graphviz()
# diag = Diagramme.DiagrammeObjets(cat,['A','B'])
# cones = CategorieCones.CategorieCones(diag)
# cones.transformer_graphviz()
# cat.ajouter_morphismes([s,s1,s2,s3])
# diagramme = Diagramme.Chemins(cat,'1','A')
# diagramme.faire_commuter()
# diagramme = Diagramme.Chemins(cat,'2','A')
# diagramme.faire_commuter()
# diagramme = Diagramme.Chemins(cat,'3','A')
# diagramme.faire_commuter()
# diagramme = Diagramme.Chemins(cat,'1','B')
# diagramme.faire_commuter()
# diagramme = Diagramme.Chemins(cat,'2','B')
# diagramme.faire_commuter()
# diagramme = Diagramme.Chemins(cat,'3','B')
# diagramme.faire_commuter()
# cat.transformer_graphviz()
# cones = CategorieCones.CategorieCones(diag)
# cones.transformer_graphviz()
# cat = Categorie.Categorie()
# cat.ajouter_objets("123")
# f,g = [Morphisme('1','2','f'),Morphisme('1','3','g')]
# cat.ajouter_morphismes([f,g])
# cat.transformer_graphviz()
# diag1 = Diagramme.DiagrammeObjets(cat,['2'])
# diag2 = Diagramme.DiagrammeIdentite(cat)
# diag1.transformer_graphviz()
# diag2.transformer_graphviz()
# bouquets = Bouquet.Bouquets(diag2,diag1)
# bouquets.transformer_graphviz()
# cat = Categorie.Categorie("Rosen")
# cat.ajouter_objets("ABfp")
# a,b,c,d,e,g = [Morphisme('A','B','a'),Morphisme('B','f','b'),Morphisme('f','B','c'),Morphisme('f','p','d'),Morphisme('p','f','e'),Morphisme('B','p','g')]
# cat.ajouter_morphismes([a,b,c,d,e,g])
# diag = Diagramme.DiagrammeIdentite(cat)
# diag.faire_commuter()
# cat.csv_loi_de_composition('lois de composition/loi.csv')
# diag = Diagramme.Fleche(cat,a)
# cat.transformer_graphviz()
# cat_fleurie = CategorieFleurie.CategorieFleurie(cat)
# cat_fleurie.ajouter_diagramme_interet(diag)
# cat_fleurie.transformer_graphviz()
# cat_cluster = CategorieClusters.CategorieClustersActifs(cat)
# cat_cluster.ajouter_diagramme_interet(diag)
# cat_cluster.transformer_graphviz()
cat = Categorie.Categorie("Test cone cluster")
cat.ajouter_objets("ABC")
a,b,c,d = [Morphisme('A','B','a'),Morphisme('A','C','b'),Morphisme('B','C','c'),Morphisme('C','C','d')]
cat.ajouter_morphismes([a,b,c,d])
diag = Triangle(cat,"CCC",[d,d,d])
diag.faire_commuter()
cat.transformer_graphviz()
cat_index = Categorie.Categorie()
cat_index.ajouter_objets("ABCD")
e,f,g = [Morphisme('A','B','e'),Morphisme('B','C','f'),Morphisme('C','D','g')]
cat_index.ajouter_morphismes([e,f,g])
cat_index.transformer_graphviz()
fonct = Foncteur.Foncteur(cat_index,cat,{"A":"B","B":"C","C":"C","D":"C"},{e:c,f:d,g:d})
fonct.transformer_graphviz()
cat_cones = CategorieCones.CategorieCones(fonct)
cat_cones.transformer_graphviz()
diag_c = DiagrammeObjets(cat,['B'])
cluster = Cluster.ClusterActif(diag_c,fonct)
cluster.transformer_graphviz()
# cat_cluster.transformer_graphviz()
# cat_cluster = CategorieClusters.CategorieClustersActifs(cat)
# cat_cluster.ajouter_diagramme_interet(fonct)
# cat_cluster.transformer_graphviz()
# cat = Categorie.Categorie("Test cocone cluster")
# cat.ajouter_objets("ABC")
# a,b,c,d = [Morphisme('B','A','a'),Morphisme('C','A','b'),Morphisme('C','B','c'),Morphisme('C','C','d')]
# cat.ajouter_morphismes([a,b,c,d])
# diag = Triangle(cat,"CCC",[d,d,d])
# diag.faire_commuter()
# cat.transformer_graphviz()
# cat_index = Categorie.Categorie()
# cat_index.ajouter_objets("DEF")
# e,f = [Morphisme('E','D','e'),Morphisme('E','F','f')]
# cat_index.ajouter_morphismes([e,f])
# cat_index.transformer_graphviz()
# fonct = Foncteur.Foncteur(cat_index,cat,{"D":"A","E":"C","F":"C"},{e:b,f:d})
# fonct.transformer_graphviz()
# cat_cocones = CategorieCocones.CategorieCocones(fonct)
# cat_cocones.transformer_graphviz()
# diag_c = DiagrammeObjets(cat,['C'])
# cluster = Cluster.ClusterActif(fonct,diag_c)
# cluster.transformer_graphviz()
# cat_cluster = CategorieClusters.CategorieClustersActifs(cat)
# cat_cluster.ajouter_diagramme_interet(fonct)
# cat_cluster.transformer_graphviz()
\ No newline at end of file
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