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

Création de Bouquet2 qui calcule les bouquets par recherche brute force

parent 2c1e1f7d
......@@ -380,7 +380,7 @@ def main():
fonct1 = Foncteur(cat_fleche,cat2,{'A':'A','B':'B'},{a:h})
fonct2 = Foncteur(cat_fleche,cat2,{'A':'C','B':'D'},{a:k})
bouquets = Bouquets(fonct1,fonct2)
bouquets = BouquetsActifs(fonct1,fonct2)
bouquets.transformer_graphviz()
......
from Morphisme import Morphisme
from CategorieCones import CategorieCones
from CategorieCocones import CategorieCocones
from config import *
import itertools
from collections import defaultdict
from copy import copy
if GRAPHVIZ_ENABLED:
from graphviz import Digraph
class BouquetAbstrait(Morphisme):
nb_viz = 0
def __eq__(self,other):
if issubclass(type(other),BouquetAbstrait):
if len([e for e in self.tiges if e not in other.tiges]) > 0:
return False
if len([e for e in other.tiges if e not in self.tiges]) > 0:
return False
return True
return False
def verifier_coherence(self):
raise NotImplementedError()
def transformer_graphviz(self, destination=None):
"""Permet de visualiser le bouquet avec graphviz
Composante rouge : diagramme 1
Composante verte : diagramme 2
Composante bleue : Cones
Composante bleue foncée : cocones
Composante orange: Bouquet"""
Bouquet.nb_viz += 1
if not hasattr(self,'cat_cones1'):
self.cat_cones1 = CategorieCones(self.foncteur1)
if not hasattr(self,'cat_cones2'):
self.cat_cones2 = CategorieCones(self.foncteur2)
if not hasattr(self,'cat_cocones1'):
self.cat_cocones1 = CategorieCocones(self.foncteur1)
if not hasattr(self,'cat_cocones2'):
self.cat_cocones2 = CategorieCocones(self.foncteur2)
image1 = self.foncteur1.categorie_image()
image2 = self.foncteur2.categorie_image()
if destination == None:
destination = "graphviz/bouquet"+str(Bouquet.nb_viz)
graph = Digraph('bouquet')
graph.attr(concentrate="true" if GRAPHVIZ_CONCENTRATE_GRAPHS else "false")
graph.attr(label="Bouquet entre "+str(self.foncteur1)+" et "+str(self.foncteur2))
for o in self.categorie.objets:
couleur = [0,0,0]
if o in image1.objets:
couleur[0] += 200
if o in image2.objets:
couleur[1] += 200
if o in [e.apex for e in self.cat_cones1.objets] or o in [e.apex for e in self.cat_cones2.objets]:
couleur[2] += 200
if o in [e.nadir for e in self.cat_cocones1.objets] or o in [e.nadir for e in self.cat_cocones2.objets]:
couleur[2] += 55
graph.node(str(o),color="#"+''.join(map(lambda x:(2-len(str(hex(x))[2:]))*"0"+str(hex(x))[2:],couleur)))#"grey60")
morphismes = self.categorie.morphismes+image1.morphismes+image2.morphismes+\
[e for cone in self.cat_cones1.objets for e in cone.jambes.values()]+\
[e for cone in self.cat_cones2.objets for e in cone.jambes.values()]+\
[e for cocone in self.cat_cocones1.objets for e in cocone.jambes.values()]+\
[e for cocone in self.cat_cocones2.objets for e in cocone.jambes.values()]+\
self.tiges
for morph in [morphismes[i] for i in range(len(morphismes)) if i==len(morphismes) or morphismes[i] not in morphismes[i+1:]]:
if not morph.is_identite or morph in [e for cone in self.cat_cones1.objets for e in cone.jambes.values()]+\
[e for cone in self.cat_cones2.objets for e in cone.jambes.values()]+\
[e for cocone in self.cat_cocones1.objets for e in cocone.jambes.values()]+\
[e for cocone in self.cat_cocones2.objets for e in cocone.jambes.values()]:
couleur = [0,0,0]
if morph in image1.morphismes:
couleur[0] += 200
if morph in image2.morphismes:
couleur[1] += 200
if morph in [e for cone in self.cat_cones1.objets for e in cone.jambes.values()]+\
[e for cone in self.cat_cones2.objets for e in cone.jambes.values()]:
couleur[2] += 200
if [e for cocone in self.cat_cocones1.objets for e in cocone.jambes.values()]+\
[e for cocone in self.cat_cocones2.objets for e in cocone.jambes.values()]:
couleur[2] += 55
if morph in self.tiges:
couleur = [255,110,0]
graph.edge(str(morph.source),str(morph.cible),label=str(morph.representant), color="#"+''.join(map(lambda x:(2-len(str(hex(x))[2:]))*"0"+str(hex(x))[2:],couleur)))
else:
graph.edge(str(morph.source),str(morph.cible),label=str(morph.representant), weight="1000", color="#"+''.join(map(lambda x:(2-len(str(hex(x))[2:]))*"0"+str(hex(x))[2:],couleur)))
graph.render(destination)
if CLEAN_GRAPHVIZ_MODEL:
import os
os.remove(destination)
class BouquetPerceptif(BouquetAbstrait):
"""Seules les contraintes sur les cônes sont prises en compte pour le bouquet perceptif"""
def __init__(self, foncteur1, foncteur2, tiges, cat_cones1=None,cat_cones2=None):
"""On peut fournir cat_cones1 et cat_cones2 pour économiser du temps de calcul."""
self.foncteur1 = foncteur1
self.foncteur2 = foncteur2
self.tiges = list(tiges) #liste de morphismes de la catégorie cible des foncteurs
self.categorie = self.foncteur1.cat_cible
self.cat_cones1 = cat_cones1
self.cat_cones2 = cat_cones2
if TOUJOURS_VERIFIER_COHERENCE:
BouquetPerceptif.verifier_coherence(self)
def verifier_coherence(self):
if self.foncteur1.cat_cible != self.foncteur2.cat_cible:
raise Exception("Incoherence Bouquet : les deux foncteurs n'ont pas la meme image.")
impl1, impl2 = [self.foncteur1.categorie_image(),self.foncteur2.categorie_image()]
for tige in self.tiges:
if tige.source not in impl1.objets:
raise Exception("Incoherence Bouquet : la tige "+str(tige)+" ne prend pas sa source dans l'image de F1")
if tige.cible not in impl2.objets:
raise Exception("Incoherence Bouquet : la tige "+str(tige)+" ne prend pas sa cible dans l'image de F2")
if self.cat_cones1 == None:
self.cat_cones1 = CategorieCones(self.foncteur1)
if self.cat_cones2 == None:
self.cat_cones2 = CategorieCones(self.foncteur2)
for cone1 in self.cat_cones1.objets:
list_qB = []
for A,pA in cone1.jambes.items():
for g in self.tiges:
if g.source == pA.cible:
list_qB += [self.categorie.Composee(pA,g)]
image_existe = False
for cone2 in self.cat_cones2.objets:
for j in cone2.jambes.values():
if j not in list_qB:
break
else:
image_existe = True
break
if not image_existe:
raise Exception("Incoherence Bouquet : le cone "+str(cone1)+" n'a pas d'image par le bouquet")
class BouquetActif(BouquetAbstrait):
"""Seules les contraintes sur les cocônes sont prises en compte pour le bouquet actif"""
def __init__(self, foncteur1, foncteur2, tiges,cat_cocones1=None,cat_cocones2=None):
"""On peut fournir cat_cocones1 et cat_cocones2 pour économiser du temps de calcul."""
self.foncteur1 = foncteur1
self.foncteur2 = foncteur2
self.tiges = list(tiges) #liste de morphismes de la catégorie cible des foncteurs
self.categorie = self.foncteur1.cat_cible
self.cat_cocones1 = cat_cocones1
self.cat_cocones2 = cat_cocones2
if TOUJOURS_VERIFIER_COHERENCE:
BouquetActif.verifier_coherence(self)
def verifier_coherence(self):
if self.foncteur1.cat_cible != self.foncteur2.cat_cible:
raise Exception("Incoherence Bouquet : les deux foncteurs n'ont pas la meme image.")
impl1, impl2 = [self.foncteur1.categorie_image(),self.foncteur2.categorie_image()]
for tige in self.tiges:
if tige.source not in impl1.objets:
raise Exception("Incoherence Bouquet : la tige "+str(tige)+" ne prend pas sa source dans l'image de F1")
if tige.cible not in impl2.objets:
raise Exception("Incoherence Bouquet : la tige "+str(tige)+" ne prend pas sa cible dans l'image de F2")
if self.cat_cocones1 == None:
self.cat_cocones1 = CategorieCocones(self.foncteur1)
if self.cat_cocones2 == None:
self.cat_cocones2 = CategorieCocones(self.foncteur2)
for cocone2 in self.cat_cocones2.objets:
list_pA = []
for B,qB in cocone2.jambes.items():
for g in self.tiges:
if g.cible == qB.source:
list_pA += [self.categorie.Composee(g,qB)]
image_existe = False
for cocone1 in self.cat_cocones1.objets:
for j in cocone1.jambes.values():
if j not in list_pA:
break
else:
image_existe = True
break
if not image_existe:
raise Exception("Incoherence Bouquet : le cocone "+str(cocone2)+" compose avec le bouquet n'a pas d'image")
class Bouquet(BouquetPerceptif,BouquetActif):
"""Un bouquet est à la fois perceptif et actif."""
def __init__(self, foncteur1, foncteur2, tiges, cat_cones1=None,cat_cones2=None,cat_cocones1=None,cat_cocones2=None):
"""On peut fournir cat_cones1, cat_cones2, cat_cocones1 et cat_cocones2 pour économiser du temps de calcul."""
BouquetPerceptif.__init__(self,foncteur1,foncteur2,tiges,cat_cones1,cat_cones2)
BouquetActif.__init__(self,foncteur1,foncteur2,tiges,cat_cocones1,cat_cocones2)
class BouquetsPerceptifs:
def __init__(self, foncteur1, foncteur2, cat_cones1=None, cat_cones2=None):
"""On peut spécifier les catégories de cônes pour économiser du temps de calcul"""
self.foncteur1 = foncteur1
self.foncteur2 = foncteur2
if self.foncteur1.cat_cible != self.foncteur2.cat_cible:
raise Exception("Incoherence BouquetsPerceptifs : les deux foncteurs n'ont pas la meme image.")
self.cat_cones1 = CategorieCones(foncteur1) if cat_cones1 == None else cat_cones1
self.cat_cones2 = CategorieCones(foncteur2) if cat_cones2 == None else cat_cones2
self.categorie = self.foncteur1.cible
self.bouquets_perceptifs = []
# on énumère toutes les flèches de D1 à D2
objets_comma_category = {(i,j):self.categorie.enumerer_composees(self.foncteur1(i),self.foncteur2(j))\
for i in self.foncteur1.source.objets for j in self.foncteur2.source.objets}
fleches = [e for liste in objets_comma_category.values() for e in liste]
# on énumère toutes les interactions de D1 à D2
for nb_fleches in range(1,len(objets_comma_category)+1):
for interaction in itertools.combinations(fleches,nb_fleches):
ajouter_bouquet = True
for cone in self.cat_cones1.objets:
fleches_generees = set()
for jambe in cone.jambes.values():
for fleche in interaction:
if fleche.source == jambe.cible:
fleches_generees |= {self.categorie.Composee(jambe,fleche)}
cone_a_l_arrivee = False
for cone2 in self.cat_cones2.objets:
if fleches_generees == set(cone2.jambes.values()):
cone_a_l_arrivee = True
break
if not cone_a_l_arrivee:
ajouter_bouquet = False
break
if ajouter_bouquet:
self.bouquets_perceptifs += [BouquetPerceptif(self.foncteur1,self.foncteur2,interaction,cat_cones1,cat_cones2)]
def transformer_graphviz(self):
for bouquet in self.bouquets_perceptifs:
bouquet.transformer_graphviz()
class BouquetsActifs:
def __init__(self, foncteur1, foncteur2, cat_cocones1=None, cat_cocones2=None):
"""On peut spécifier les catégories de cocônes pour économiser du temps de calcul"""
self.foncteur1 = foncteur1
self.foncteur2 = foncteur2
if self.foncteur1.cat_cible != self.foncteur2.cat_cible:
raise Exception("Incoherence BouquetsActifs : les deux foncteurs n'ont pas la meme image.")
self.cat_cocones1 = CategorieCocones(foncteur1) if cat_cocones1 == None else cat_cocones1
self.cat_cocones2 = CategorieCocones(foncteur2) if cat_cocones2 == None else cat_cocones2
self.categorie = self.foncteur1.cible
self.bouquets_actifs = []
# on énumère toutes les flèches de D1 à D2
objets_comma_category = {(i,j):self.categorie.enumerer_composees(self.foncteur1(i),self.foncteur2(j))\
for i in self.foncteur1.source.objets for j in self.foncteur2.source.objets}
fleches = [e for liste in objets_comma_category.values() for e in liste]
# on énumère toutes les interactions de D1 à D2
for nb_fleches in range(1,len(objets_comma_category)+1):
for interaction in itertools.combinations(fleches,nb_fleches):
ajouter_bouquet = True
for cocone in self.cat_cocones2.objets:
fleches_generees = set()
for jambe in cocone.jambes.values():
for fleche in interaction:
if fleche.cible == jambe.source:
fleches_generees |= {self.categorie.Composee(fleche,jambe)}
cocone_au_depart = False
for cocone1 in self.cat_cocones1.objets:
if fleches_generees == set(cocone1.jambes.values()):
cocone_au_depart = True
break
if not cocone_au_depart:
ajouter_bouquet = False
break
if ajouter_bouquet:
self.bouquets_actifs += [BouquetActif(self.foncteur1,self.foncteur2,interaction,cat_cocones1,cat_cocones2)]
def transformer_graphviz(self):
for bouquet in self.bouquets_actifs:
bouquet.transformer_graphviz()
class Bouquets:
def __init__(self, foncteur1, foncteur2, cat_cones1=None, cat_cones2=None, cat_cocones1=None, cat_cocones2=None):
"""On peut spécifier les catégories de cônes et cocônes pour économiser du temps de calcul"""
self.foncteur1 = foncteur1
self.foncteur2 = foncteur2
self.cat_cones1 = cat_cones1
self.cat_cones2 = cat_cones2
self.cat_cocones1 = cat_cocones1
self.cat_cocones2 = cat_cocones2
self.bouquets_perceptifs = BouquetsPerceptifs(foncteur1,foncteur2,cat_cones1,cat_cones2)
print("fin création bouquets perceptifs")
self.bouquets_actifs = BouquetsActifs(foncteur1,foncteur2,cat_cocones1,cat_cocones2)
print("fin création bouquets actifs")
self.bouquets = [Bouquet(foncteur1,foncteur2,b.tiges,cat_cones1,cat_cones2,cat_cocones1,cat_cocones2)\
for b in self.bouquets_perceptifs.bouquets_perceptifs if b in self.bouquets_actifs.bouquets_actifs]
def transformer_graphviz(self):
for bouquet in self.bouquets:
bouquet.transformer_graphviz()
def main():
# import random
# random.seed(156)
# import CategorieAleatoire
# cat1 = CategorieAleatoire.CategorieAleaPreOrdreAcyclique(10,0.5)
# from Morphisme import Morphisme
# nouveau = Morphisme(4,7,'m')
# cat1.ajouter_morphisme(nouveau)
# cat1.transformer_graphviz()
# import Diagramme
# diag1 = Diagramme.DiagrammeAlea(cat1,1)
# diag1.transformer_graphviz()
# for i in range(100):
# random.random()
# diag2 = Diagramme.DiagrammeAlea(cat1,1)
# diag2.transformer_graphviz()
# import CategorieCones, CategorieCocones
# cat_cones1 = CategorieCones.CategorieCones(diag1)
# cat_cones1.transformer_graphviz(destination="graphviz/cat_cones1")
# cat_cones2 = CategorieCones.CategorieCones(diag2)
# cat_cones2.transformer_graphviz(destination="graphviz/cat_cones2")
# cat_cocones1 = CategorieCocones.CategorieCocones(diag1)
# cat_cocones1.transformer_graphviz(destination="graphviz/cat_cocones1")
# cat_cocones2 = CategorieCocones.CategorieCocones(diag2)
# cat_cocones2.transformer_graphviz(destination="graphviz/cat_cocones2")
# bouquets = Bouquets(diag1,diag2)
# bouquets.transformer_graphviz()
from Categorie import Categorie
from Morphisme import Morphisme
from Foncteur import Foncteur
cat = Categorie()
cat.ajouter_objets("ABCDO")
f,g,h,i,j,k,l,m = [Morphisme('O','A','f'),Morphisme('O','B','g'),Morphisme('A','B','h'),Morphisme('O','C','i'),Morphisme('O','D','j'),Morphisme('C','D','k'),Morphisme('B','C','l'),Morphisme('A','D','m')]
cat.ajouter_morphismes([f,g,h,i,j,k,l,m])
from CategoriePreordre import CategoriePreordre
cat2 = CategoriePreordre(cat)
n,o = [Morphisme('O','A','n'),Morphisme('O','B','o')]
cat2.ajouter_morphismes([n,o])
cat2.transformer_graphviz()
cat_fleche = Categorie()
cat_fleche.ajouter_objets("AB")
a = Morphisme('A','B','a')
cat_fleche.ajouter_morphismes([a])
fonct1 = Foncteur(cat_fleche,cat2,{'A':'A','B':'B'},{a:h})
fonct2 = Foncteur(cat_fleche,cat2,{'A':'C','B':'D'},{a:k})
bouquets = BouquetsActifs(fonct1,fonct2)
bouquets.transformer_graphviz()
if __name__ == '__main__':
main()
\ No newline at end of file
......@@ -30,7 +30,7 @@ class Morphisme:
return str(self.representant)+' : '+str(self.source)+" -> "+str(self.cible)
def __repr__(self):
return pretty_print(self)+","+super().__repr__().split('object at ')[-1].split('>')[0]
return self.pretty_print()+","+super().__repr__().split('object at ')[-1].split('>')[0]
def __len__(self):
return len(self.composee)
......
......@@ -44,79 +44,135 @@ from Morphisme import Morphisme
# b = Bouquet.Bouquets(diag2,diag1)
# b.transformer_graphviz()
# cat = Categorie.Categorie()
# cat.ajouter_objets("AB")
# f = Morphisme('A','B','f')
# cat.ajouter_morphismes([f])
# cat.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.DiagrammeObjets(cat,'A')
# diag2 = Diagramme.DiagrammeObjets(cat,'B')
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()
f = diag1.est_prohomologue_a(diag2)
if f != None:
f.transformer_graphviz()
# b = Bouquet.Bouquets(diag1,diag2)
# b.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()
random.seed(1561741474774747587575775887517)
cat = CategorieAleatoire.CategorieAlea(7,8)
cat.transformer_graphviz()
diag1.champ_perceptif().transformer_graphviz()
diag2.champ_perceptif().transformer_graphviz()
diag = Diagramme.DiagrammeAlea(cat,3)
diag.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()
# 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])
# 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)
# 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[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()
# 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",2)
# diagramme.transformer_graphviz()
# diagramme.faire_commuter()
diagramme = Diagramme.Chemins(cat,"S",6)
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()
# diagramme = Diagramme.Chemins(cat,"S",4)
# diagramme.transformer_graphviz()
# diagramme.faire_commuter()
cat.transformer_graphviz()
# 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_])
cones = CategorieCones.CategorieCones(diag)
cones.transformer_graphviz()
# 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()
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