Cette nouvelle approche du Small World est due en grande partie à M.Newman

-> Un des gros problèmes que l’on rencontre dans l’étude des réseaux sociaux est l’impartialité des données reçues lors de la construction du réseau: chaque personne du réseau n’a pas forcément la même notion de “connaissance” et cela peut donc biaiser les informations et nuire à l’étude du réseau. Un moyen plus simple de procéder et donc de ne plus prendre en compte les relations directes entre les personnes du réseau mais leur appartenance à certains groupes (associations sportives, clubs…). En plus d’améliorer la qualité du graphe, ce type de construction s’appuyant uniquement sur des bases de données permet de construire des graphes beaucoup plus gros et beaucoup plus rapidement qu’avec un modèle simple.

-> Chaque graphe bipartite est donc composé de 2 parties : une partie représentant les groupes pris en compte pour l’étude du réseau et une partie représentant les personnes appartenant au réseau, chacune étant reliée au(x) groupe(s) au(x)quel(s) elle appartient. Il est possible, à partir d’un graphe bipartite, de revenir à un graphe simple (voir présentation power point) et ainsi appliquer les formules permettant de trouver la densité locale et le chemin moyen.

TIPE - Réseau d\’affiliation

Petit détail sans doute important, les quelques lignes au début de la présentation:

type gens = {nom : string ; mutable relation : string list};;
type monde = {mutable reseau:gens list};;

représentent la manière dont j’ai simulé le monde. Le type gens, est un type qui représente les personnes, avec un nom et une liste de relation, et le type monde représente le réseau en lui même, avec simplement une liste de gens. Les relations entre les personnes étant déjà prises en compte dans le type gens, une liste de gens suffit à définir entièrement un réseau.

Présentation power point

(*typer un monde et des gens*)
type gens = {nom : string ; mutable relation : string list};;
type monde = {mutable reseau : gens list};;

(*une personne appartient elle au monde?*)
let rec appartient p = fun monde ->
match monde.reseau with
[] -> false
|(a::r) -> (a = p) or (appartient p {reseau = r});;

(*créer un monde vide*)
let creer_monde = fun () -> {reseau = []};;

(*ajouter une personne à un monde*)
let ajouter_gens p monde =
if not(appartient p monde) then
monde.reseau <- p::(monde.reseau);;

(*creer une personne*)
let creer_gens b = {nom = b; relation = []};;

(*test*)
let m = creer_monde();;
let bob = creer_gens “bob”;;
ajouter_gens bob m;;
appartient bob m;;

let aj_rel p1 p2 = p2.relation <- (p1.nom)::(p2.relation);;

(*mettre une personne en tête du reseau d’un monde*)
let rec en_tete p = fun monde ->  match monde.reseau with
[] -> ajouter_gens p monde
|(a::r) when a = p -> ()
|(a::r) -> monde.reseau <- r@[a]; en_tete p monde;;

(*ajouter une relation à un monde*)
let ajouter_relation p1 p2 = fun monde -> match monde.reseau with
l when (appartient p1 monde) && (appartient p2 monde) ->
en_tete p1 monde;
let (a::r) = monde.reseau in
aj_rel p2 a;
monde.reseau <- a::r;
en_tete p2 monde;
let (b::q) = monde.reseau in
aj_rel p1 b;
monde.reseau <- (b::q)
|l -> aj_rel p1 p2;
aj_rel p2 p1;
ajouter_gens p1 monde; ajouter_gens p2 monde;;

(*test*)
let m = {reseau = [{nom = "bob" ; relation = []};{nom = “a”; relation = []};{nom = “”;relation = []}]};;
let a = {nom = “bob” ; relation = []} and
b={nom = “a”; relation = []} and
c = {nom = “”;relation = []} ;;
ajouter_relation a b m;;

(*calculer le nombre de gens dans un monde*)
let rec longueur_monde = fun monde -> match monde.reseau with
[] -> 0
|(a::r) -> 1 + (longueur_monde {reseau    = r});;

(*créer un tableau à partir d’un monde*)
let tableau_gens = fun monde ->
let n = longueur_monde monde in
let t = make_vect n {nom=”";relation=[]} in
let rec tabaux = fun
-1 _ -> ()
|i [] -> failwith “y’a nettement un problème”
|i (a::r) -> t.(i) <- a;
tabaux (i-1) r;
in
tabaux (n-1) monde.reseau;
t;;

(*associer un numéro à une personne*)
let clef a monde =
let t = tableau_gens monde and cle = ref 0 in
for i = 0 to ((longueur_monde monde)-1) do
if a = t.(i) then cle := i;
done;
!cle;;

(*renvoie la personne assaciée à un nom*)
let rec nom_gens s = fun monde ->
match monde.reseau with
[] -> failwith “le gars n’existe pas”
|(a::r) when a.nom = s -> a
|(a::r) -> nom_gens s {reseau = r};;

(*renvoie la liste des clef des relation d’une personne*)
let rec list_rel = fun p monde ->
match p.relation with
[] -> []
|(a::r) -> (clef (nom_gens a monde) monde) :: (list_rel {nom = p.nom; relation = r} monde);;

(*renvoie le tableau des listes des relations*)
let tableau_relation = fun monde ->
let t = make_vect (longueur_monde monde) [] in
let rec tabaux = fun
-1 _ -> ()
|i [] -> failwith “y’a nettement un problème”
|i (a::r) -> t.(i) <- list_rel a monde;
tabaux (i-1) r;
in
tabaux ((longueur_monde monde)-1) monde.reseau;
t;;

(*test*)
tableau_relation m;;

#open “graphics”;;
open_graph “”;;

(*dessine les points correspondant au gens sur un cercle*)
let trace_gens = fun monde ->
let n = longueur_monde monde in
for i = 0 to n do
let i’ = float_of_int i and n’=float_of_int n in
let a = 400.+.300.*.cos(2.*.3.14159*.i’/.n’)
and b = 400.+.300.*.sin(2.*.3.14159*.i’/.n’) in
plot (int_of_float a) (int_of_float b)
done;;

(*test*)
trace_gens m;;

(*trace les relations entre les gens toujours sur un cercle*)
let trace_rel = fun p monde ->
let cle = float_of_int (clef p monde) and n = float_of_int (longueur_monde monde) in
let a = 400.+.300.*.cos(2.*.3.14159*.cle/.n)
and b = 400.+.300.*.sin(2.*.3.14159*.cle/.n) in
let rec traaux = fun
[] -> ()
|(q::r) -> let cle’ = float_of_int (clef (nom_gens q monde) monde) in
let c = 400.+.300.*.cos(2.*.3.14159*.cle’/.n)
and d = 400.+.300.*.sin(2.*.3.14159*.cle’/.n) in
moveto (int_of_float a) (int_of_float b);
lineto (int_of_float c) (int_of_float d);
traaux r;
in
traaux p.relation;;

(*trace le monde (les gens et les relations sur un cercle)*)
let trace_monde = fun monde ->
clear_graph ();
trace_gens monde;
let l = ref monde.reseau in
while !l <> [] do
trace_rel (hd !l) monde;
l := tl !l
done;;

(*test*)
trace_monde m;;

(*associe à une liste d’entiers une liste de chaines de caractères*)
let rec string_list = fun
|[] -> []
|(a::r) -> (string_of_int a)::string_list r;;

(*associe à un tableau de listes d’entiers un monde*)
let tableau_monde = fun tab ->
let monde = creer_monde () and n = vect_length tab in
let t = make_vect n [] in
for i = 0 to n-1 do
t.(i) <- string_list (tab.(i))
done;
for i = 0 to n-1 do
ajouter_gens {nom = string_of_int i; relation = t.(i)} monde
done;
monde;;

(*test*)
let t = [|[1;2];[3;0];[3;0];[1;2]|];;
let mm = tableau_monde t;;
trace_monde mm;;

(*crée un monde ordonné*)
let monde_ordonne = fun n k ->
let t = make_vect n [] in
for i = 0 to n-1 do
for j=1 to k/2 do
t.(i) <-((n+i+j)mod n)::((n+i-j)mod n)::t.(i)
done;
done;
tableau_monde t;;

(*test*)
let monde = monde_ordonne 10 2;;
trace_monde monde;;

(*met un nom en tête des relations d’une personne*)
let rec tete = fun p1 p2 ->
match p2.relation with
[] -> p2.relation <- [p1]
|(a::r) when a = p1 -> ()
|(a::r) -> p2.relation <- r@[a];;

(*supprime une relation*)
let sup_rel = fun a p ->
tete a p;
match p.relation with
[] -> failwith “il ne connait personne!”
|(a::r) -> p.relation <- r;;

(*supprime une relation entre 2 personnes (la première relation d’une personne)*)
let sup_relation = fun n monde ->
let p = nom_gens n monde in
match p.relation with
[] -> failwith “il ne connait personne”
|(a::r) -> let a’ = nom_gens a monde in
sup_rel a p;
sup_rel p.nom a’;;

(*test*)
let m = {reseau =
[{nom = "a"; relation = ["bob";"1"]}; {nom = “”; relation = []};
{nom = “bob”; relation = ["1";"a"]}; {nom=”1″;relation=["a";"bob"]}]};;
sup_relation “a” m;;
m;;

(*renvoie la personne associée à un monde*)
let anti_clef = fun k monde ->
let t = tableau_gens monde in
(nom_gens t.(k).nom monde);;

(*compte le nombre de relation d’une personne*)
let rec nb_rel = fun p -> match p.relation with
|[] -> 0
|(a::r) -> 1 + nb_rel {nom=”";relation=r};;

(*compte le nombre de relations dans un monde*)
let nb_relation = fun monde ->
let rec nb = fun monde ->
match monde.reseau with
[] -> 0
|(a::r) -> (nb_rel a) + nb {reseau = r};
in
(nb monde)/2;;

(*dérange plus ou moins le monde*)
let desordre = fun p monde ->
let n = nb_relation monde in
let n’ = longueur_monde monde in
let k = int_of_float (p*.(float_of_int n)) in
let i = ref 0 in
while !i<k do
let i’ = random__int (n’-1) in
if ((anti_clef i’ monde).relation <> []) then
(begin
sup_relation (anti_clef i’ monde).nom monde;
i:=!i+1;
let i” = random__int (n’-1) and i’ = random__int (n’-1) in
ajouter_relation (anti_clef i’ monde) (anti_clef i” monde) monde;
end;)
done;;

(*test*)
let m’=monde_ordonne 50 10;;
desordre 1. m’;;
trace_monde m’;;

(*renvoie vrai si les 2 personnes sont en relation directe*)
let rec rel p1 p2 = match p1.relation with
[] -> false
|(a::r) -> (a=p2.nom) or rel {nom=p1.nom;relation=r} p2;;

(*test*)
monde_ordonne 10 2;;
rel {nom = “9″; relation = ["0"; "8"]} {nom = “4″; relation = ["5"; "3"]};;

(*dis si les relation d’une personne (p1) sont en relation directe avec une autre personne (p2)*)
let rec rel2 = fun p1 p2 monde -> match p1.relation with
|[] -> false
|(a::r) when (rel (nom_gens a monde) p2) -> true
|(a::r) -> rel2 {nom=p1.nom;relation=r} p2 monde;;

(*dit si un élément appartient à une liste*)
let rec app x = fun
[] -> false
|(a::r) -> if a=x then true else false;;

(*ajoute à une liste l’ensemble des liste de relation d’une personne*)
let rec conc l p = match p.relation with
[] -> l
|(a::r) -> let k=conc l {nom=p.nom;relation=r} in
if app a k then k
else a::k;;

(*supprime les doublons dans une liste*)
let rec sup_doub = fun
[] -> []
|(a::r) -> if (app a r) then r else a::sup_doub r;;

(*renvoie la liste des relation des relation d’une personne*)
let rec rel_rel = fun p monde -> match p.relation with
[] -> []
|(a::r) -> (nom_gens a monde).relation@(rel_rel {nom=p.nom;relation=r} monde);;

(*calcul le chemin le plus court entre deux personnes*)
let path = fun p1 p2 monde->
let rec pathaux monde= fun
_ p1 p2 when (rel p1 p2) or (rel p2 p1)-> 1
|_ p1 p2 when (rel2 p1 p2 monde) or (rel2 p2 p1 monde) -> 2
|n _ _ when n>(longueur_monde monde) -> failwith “il ne sont pas en relation”
|n p1 p2 -> 1+(pathaux monde (n+1) p1 {nom=p2.nom;relation=sup_doub ((rel_rel p2 monde))});
in
pathaux monde 0 p1 p2;;

(*test*)
let m = monde_ordonne 5 2;;
path {nom = “4″; relation = ["0"; "3"]}  {nom = “1″; relation = ["2"; "0"]} m;;
let m = monde_ordonne 50 2;;
path {nom = “49″; relation = ["0"; "48"]}  {nom = “14″; relation = ["15"; "13"]} m;;

(*calcule la factorielle d’un nombre*)
let rec factorielle = fun
0 -> 1
|n -> n * factorielle (n-1);;

(*calcule le chemin le plus court moyen entre deux personnes*)
let chemin_moyen = fun monde ->
let chemin = ref 0. and n = longueur_monde monde in
let n’=ref (n*n) in
for i = 0 to (n-1) do
for j=0 to n-1 do
try chemin:=!chemin +. float_of_int (path (anti_clef i monde) (anti_clef j monde) monde)
with Failure “il ne sont pas en relation” -> n’ := !n’-1
done;
done;
!chemin/.float_of_int (!n’);;

(*test*)
let m=monde_ordonne 10 4;;
chemin_moyen m;;
desordre 0.5 m;;
chemin_moyen m;;

(*trace le chemin moyen le plus court en fonction du désordre*)
let trace_chemin = fun n k ->
clear_graph ();
let m = monde_ordonne n k in
moveto 0 (int_of_float (200.*.chemin_moyen m));
for i = 1 to 30 do
let m = monde_ordonne n k in
let p = (float_of_int i) /. 30. in
desordre p m;
lineto (i*20) (int_of_float (200.*.chemin_moyen m));
done;;

(*test*)
trace_chemin 30 12;;

(*créer un monde à n personnes k relations et une part d’aléatoire p*)
let smallworld = fun n k p ->
let m = monde_ordonne n k in
desordre p m;
m;;

(*test*)
let m = smallworld 60 20 1.;; trace_monde m;;

(*crée un tableau de tableau de nom à partir d’un monde*)
let tab_carre_gens = fun monde ->
let n = longueur_monde monde in
let k = (int_of_float (sqrt (float_of_int n)))
and l = ref monde.reseau in
let mat = make_matrix k k “” in
for i = 0 to k-1 do
for j = 0 to k-1 do
if !l <> [] then
begin
mat.(i).(j) <- (hd !l).nom;
l := tl !l;
end
done;
done;
mat;;

(*renvoie la “double clef” d’une personne*)
let double_clef = fun p monde ->
let tab = tab_carre_gens monde in
let n = longueur_monde monde in
let k = (int_of_float (sqrt (float_of_int n))) in
let clef = ref (0,0) in
for i = 0 to k-1 do
for j = 0 to k-1 do
if p.nom = tab.(i).(j) then
clef := (i,j)
done;
done;
!clef;;

(*renvoie la personne associée à une “double clef”*)
let anti_double_clef = fun (i,j) monde ->
let tab = tab_carre_gens monde in
nom_gens tab.(i).(j) monde;;

(*renvoie la liste des “double clef” d’une relation*)
let rec double_clef_list = fun p monde ->
match p.relation with
[] -> []
|(a::r) -> (double_clef (nom_gens a monde) monde)::(double_clef_list {nom = p.nom; relation = r} monde);;

(*test*)
double_clef_list {nom = “6″; relation = ["8"; "4"; "7"; "5"]} m;;

(*crée la matrice des relations d’un monde*)
let tab_carre_relation = fun monde ->
let n = longueur_monde monde in
let k = (int_of_float (sqrt (float_of_int n))) in
let tab = make_matrix k k [] in
for i = 0 to k-1 do
for j = 0 to k-1 do
tab.(i).(j) <- double_clef_list (anti_double_clef (i,j) monde) monde
done;
done;
tab;;

(*test*)
let m = monde_ordonne 10 4;;
tab_carre_relation m;;

(*dessine les gens d’un monde sur un carré*)
let trace_carre_gens = fun monde ->
let n = longueur_monde monde in
let k = (int_of_float (sqrt (float_of_int n))) in
let tab = tab_carre_gens monde in
set_color red;
for i = 0 to k-1 do
for j = 0 to k-1 do
plot (50*(i+1)) (50*(j+1));
plot (50*(i+1)+1) (50*(j+1)+1);
plot (50*(i+1)-1) (50*(j+1)-1);
plot (50*(i+1)-1) (50*(j+1)+1);
plot (50*(i+1)+1) (50*(j+1)-1);
done;
done;
set_color black;;

(*dessine les relations entre une personne et ses relations*)
let trace_carre_relation = fun p q monde ->
let l = ref p.relation in
while !l <> [] do
let (a,b) = double_clef p monde in
let (c,d) = double_clef (nom_gens (hd !l) monde) monde in
if (abs(d-b)+abs(c-a))>q then
set_color blue
else
set_color black;
moveto ((a+1)*50) ((b+1)*50);
lineto ((c+1)*50) ((d+1)*50);
l:=tl !l
done;;

(*dessine le monde en carré*)
let trace_carre = fun monde p->
let n = longueur_monde monde in
let k = (int_of_float (sqrt (float_of_int n))) in
let tab = tab_carre_gens monde in
clear_graph ();
trace_carre_gens monde;
for i = 0 to k-1 do
for j=0 to k-1 do
trace_carre_relation (anti_double_clef (i,j) monde) p monde
done;
done;;

(*prend une liste de couple et renvoie une liste de chaines*)
let rec list_string = fun
[] -> []
|(q::r) -> let a = string_of_int (fst q) and b = string_of_int (snd q) in
(”(”^a^”,”^b^”)”)::list_string r;;

(*associe un monde à une matrice de listes de couples*)
let mat_monde = fun mat ->
let k = vect_length mat in
let m = creer_monde () in
for i = 0 to k-1 do
for j = 0 to k-1 do
ajouter_gens {nom=”(”^(string_of_int i)^”,”^(string_of_int j)^”)”; relation = list_string mat.(i).(j)} m
done;
done;
m;;

(*crée une “bonne” matrice*)
let mat = fun n p ->
let h = (int_of_float (sqrt (float_of_int n))) in
let m = make_matrix h h [] in
for i = 0 to h-1 do
for j = 0 to h-1 do
let li = ref [] in
for k = 0 to h-1 do
for l = 0 to h-1 do
if (abs(k-i)+abs(l-j))<=p then m.(i).(j) <- (k,l)::m.(i).(j)
done;
done;
done;
done;
m;;

(*crée un monde ordonné avec n personnes connaissant les personnes à une distance p d’eux*)
let monde_ordonne2 = fun n p ->
let m = mat n p in
mat_monde m;;

(*test*)
let m = monde_ordonne2 25 1;; trace_carre m;;

(*calcule a^b*)
let rec e = fun
a 0 -> 1
|a b -> a*(e a (b-1));;

(*calcule la longueur d’une list*)
let rec list_length = fun
[] -> 0
|(a::r) -> 1+list_length r;;

(*crée un monde avec n personnes connaissant les personnes à une distance p d’eux plus k personnes loin*)
let smallworld2 = fun n p k ->
let m = mat n p in
let h = vect_length m in
for i=0 to h-1 do
for j=0 to h-1 do
let la = ref k in
while !la <> 0 && ((list_length m.(i).(j)) < 2*(e 2 p)+k) do
let (k,l) = (random__int (h-1),random__int (h-1)) in
if (abs(k-i)+abs(l-j))>p then
begin
m.(i).(j) <- sup_doub ((k,l)::m.(i).(j));
la := !la - 1;
end;
done;
done;
done;
mat_monde m;;

(*test*)
let m = smallworld2 36 1 0;;trace_carre m 1;;
trace_carre (smallworld2 121 1 1) 1;;

(*trace le chemin le plus court en fonction du nombre de relations à longue distance*)
let trace_chemin2 = fun n p ->
clear_graph ();
moveto 0 (int_of_float (200.*.chemin_moyen (smallworld2 n p 0)));
for i = 1 to 30 do
lineto (i*20) (int_of_float (200.*.chemin_moyen (smallworld2 n p i)));
done;;

(*test*)
trace_chemin2 25 1;;

Prémices

Je vous invite à lire, si ce n’est pas déjà fait, l’article expliquant en quelques lignes le modèle que nous avons choisi pour illustrer la théorie.

Retour à nos approches de la problématique

1. le modèle de Watts-Strogatz - monde de 1000 personnes , 10 voisins et un coefficient alétoire p décrivant [0,1] - offre une première réponse et justifie qu’il existe un chemin moyen minimum bien inférieur aux idées reçues. Pour en apprendre plus sur ce modèle je vous conseille de lire le début de ce fichier pdf: Watts-Strogatz model
   Mais ce modèle de Watts-Strogatz n’est qu’un monde 1000 personnes, finalement déjà un petit monde, alors quand est-il des Grands Graphes ?
   Néanmoins cette première réponse offerte par ce modèle nous permet de justifier de la cohérence de notre travail, cette théorie du small world a donc une raison d’être, mais ce n’est pas encore une réponse satisfaisante.
    
2. la modélisation couplée à la puissance des machines actuelles nous permet de lancer des calculs bien plus important tels que des mondes de 10 000 (10min de calcul) voir 100 000 personnes (24h de calcul). Le calcul de 1 000 000 est en court ce mois-ci, nous y avons ajouter un algorithme d’estimation du temps pour connaître “rapidement” le temps nécessaire pour arriver au résultat final du chemin minimum moyen.
   Ajoutons à cela le travail de Laetitia sur les Grands Graphes qui nous sort de ce premier modèle, car un monde est lui-même composé de plusieurs small world (entreprises, clubs de sports, associations, etc)
    
3. L’idée sur laquelle je travail actuellement est d’utiliser des techniques de régression puissantes nous permettant avec beaucoup de moyens calculs (donc peu d’efforts) de pouvoir prédire ce que serait un calcul d’un monde gigantesque!
   • les régressions polynomiales reposent sur des calculs de matrices de Vandermonde. Je suis en train de coder tout ceci en python.
   • je dois aussi stocker plusieurs calculs pour me créer une base données que j’exploiterai lors de la régression.
   • enfin il y aura une part dans l’algorithme vérifiant que la courbe obtenue par régression est acceptable simplement en faisant un calcul pour un monde sortant du maximum stocké dans la base de donné et nous retournant la marge d’erreur entre le résultat obtenu et le résultat de la courbe.

Article en cours d’écriture…

Small World Project Fichiers

I - Comment modéliser un monde?

Voici le genre de question dont une ou plusieurs vies ne seraient assez pour y répondre. Il nous faut donc commencer par trouver une modélisation la plus simple possible et ensuite intégrer de nouveaux paramètres pour affiner le modèle.

les observations:

1. un monde contient un nombre, disons N, de personnes
2. chaque personne connait par proximité ses voisins, posons que chacun connaît ses Z voisins les plus proches (nous verrons pour notre représentation qu’il nous faudra prendre un nombre Z pair)

Voilà un premier modèle, que l’on nomme couramment monde ordonné, car ce monde est symétrique dans toutes les directions.
Il nous faut donc introduire un nouveau paramètre si l’on veut pouvoir approcher un peu plus de la réalité.

3ème observation:
il arrive que des personnes très éloignées, en distance, se connaissent pour des raisons qu’on ne peut traduire mathématiquement. Du moins, une répartition aléatoire de type gaussienne - ajoutant un nombre de connexions aléatoires proportionnelles au nombre total de connexions du monde ordonné - modélise assez bien ce type de relation et rendrait notre modèle plus réaliste.

Conclusion sur le modèle envisagé

Nous décidons donc de créer un monde de N, chaque personne connaissant ses Z voisins les plus proches et enfin on introduit un paramètre p correspondant au pourcentage de relations aléatoires que l’on ajoutera dans le monde.

II - Pour faire marcher ce modèle il est nécessaire d’installer

• python2.3 ou plus récent
• scipy
• numpy
• pylab
• matplotlib

Il faut aussi maîtriser les bases de python pour comprendre comment utiliser et exploiter le modèle. Et avoir lu le résumé de la théorie du small world ou en connaître la substance.

III - Bases du modèle

Le modèle repose sur l’utilisation des dictionnaires de python qui offre une grande maniabilité pour les calculs. Chaque personne de notre monde est une clé du dictionnaire et la valeur de cette clé est une liste constituée de ses connaissances (on nommera une personne: node)

IV - Un Petit Exemple :

>>> g = {}
>>> g[0] = [1,2]
>>> g[1] = [0,3]
>>> g[2] = [0,3]
>>> g[3] = [1,2,4]
>>> g[4] = [3]
>>> g
{0: [1, 2], 1: [0, 3], 2: [0, 3], 3: [1, 2, 4], 4: [3]}

Ici node0 connaît node1 et node2, etc.

V - Affichage d’un monde

On place chaque personne est placée sur un cercle et une connaissance est modélisée par un trait entre ces deux personnes. Ce n’est qu’une façon de voir les choses, d’autres modélisations sont possibles. Alexandre s’intéresse à celle présentant le monde en carré.