Truth-seeking network of agents learning from nature and learning from others : whenTopology trumps ability

extensions [matrix]


turtles-own [
  liste_croyance            ;liste des croyances au cours du temps
  liste_performence         ;liste des performences au cours du temps
  liste_ind_nature          ;liste des indices naturels  au cours du temps représentant la qualité d'énquête
                            ;cette liste suit une gaussienne de moyenne parametre_a_estimer
  liste_estime_direct       ;propre fondement sur l'estimation du paramètre

  liste_conf_epist          ;liste des confiances épistémiques que possèdent un agent envers les autres agents

  expert                    ;renseigne si l'agent est expert ou non 1=expert 0=layman
  x-pos                     ;position x de l'agent
  y-pos                     ;position y de l'agent

  indegree                  ; la somme des poids de liens de confiance pointant vers l'agent
  nb_out_neighboors         ; le nombre de voisins auprès desquels l'agent recueille de l'info
  couple                     ; le couple (dernière perf , nb_out_neighboors)
]

globals [
  list_perf_glob            ;liste des performences globales au cours du temps
  list_perf_expert          ;liste des performences globales des experts au cours du temps
  list_perf_lay             ;liste des performences globales des laymans au cours du temps
  matrice                   ; la matrice du graphe de confiance sour forme de liste des ligne de la matrice
  matrix                    ; la matrice du graphe de confiance sous forme d'objet 'matrix' (extension spéciale)
  coeff_matrix                       ; une valeur pour montrer comment récupérer une cellul
]

to setup
  clear-all
  if ecart_type_expert >= ecart_type_laymen
  [
    clear-output
    output-write "problème d'initialisation des paramètres d'écart-type"
    stop
  ]

  if (number_of_agents < 2) or (number_of_agents > 1000)
  [
    clear-output
    output-write "Le nombre d'agents doit être compris entre 2 et 1000"
    stop
  ]

  random-seed seed-random
  create_turtles
  init
  init_conf_epist
  add_arrow
  set-up-matrice

  reset-ticks
end 




;création des agents

to create_turtles
  let nb_expert ( (round ( proportion_expert * number_of_agents) ) - 1 )
  let nb_tortue number_of_agents

  create-turtles 1
  [
    set x-pos 0 set y-pos 0
    ifelse agent1_expert
    [ set expert true
      set nb_tortue (nb_tortue - 1 )
      set nb_expert (nb_expert - 1 ) ]
    [ set expert false
      set nb_tortue (nb_tortue - 1 ) ]
    ifelse expert
    [ set color blue ]
    [ set color red ]
    set shape "circle"
  ]

  let nb (number_of_agents - 1)
  let radius 20
  let start_radian 0
  let increment_angle (360 / nb)
  let increment_radian (increment_angle * pi)

  while [nb != 0]
  [
    let x (sin(start_radian) * radius)
    let y (cos(start_radian) * radius)
   create-turtles 1
   [
      set x-pos x set y-pos y
      setxy x-pos y-pos
      ifelse random nb_tortue > nb_expert
      [ set expert false
        set nb_tortue (nb_tortue - 1 ) ]
      [ set expert true
        set nb_tortue (nb_tortue - 1 )
        set nb_expert (nb_expert - 1 ) ]
      ifelse expert
      [ set color blue ]
      [ set color red ]
      set shape "circle"
   ]
   set start_radian (start_radian + increment_radian)
   set nb (nb - 1)
  ]
end 



;initialisation des listes des agents

to init
  ask turtles
  [
    set liste_croyance []
    set liste_performence []
    set liste_ind_nature []
    set liste_estime_direct []
    set liste_conf_epist []
    set indegree 0

    set liste_croyance lput (random 100 / 100) liste_croyance
    set liste_ind_nature lput (random 100 / 100) liste_ind_nature
  ]

  set list_perf_glob []
  set list_perf_expert []
  set list_perf_lay []
end 



;initialisation des confiances entre les agents

to init_conf_epist
  let i 0
  let j 0
  if modeles_relations = "master"
  [
    foreach sort turtles
    [
        set j 0
        foreach sort turtles
        [
            ifelse i = j
            [
              ifelse i = 0
              [ask turtle i [ set liste_conf_epist lput 0 liste_conf_epist] ]
              [ask turtle i [ set liste_conf_epist lput (1 / 2) liste_conf_epist] ]
            ]
            [
              ifelse i = 0
              [ask turtle i [ set liste_conf_epist lput (1 / (number_of_agents - 1) ) liste_conf_epist] ]
              [
                ifelse j = 0
                [ask turtle i [ set liste_conf_epist lput (1 / 2) liste_conf_epist] ]
                [ask turtle i [ set liste_conf_epist lput 0 liste_conf_epist] ]
              ]
            ]
            set j (j + 1)
         ]
        set i (i + 1)

    ]
  ]
  if modeles_relations = "circle"
  [
    foreach sort turtles
    [
        set j 0
        foreach sort turtles
        [
            ifelse (i = j) or (abs (i - j) = 1 ) or (abs (i - j) = ( number_of_agents - 1 ) )
            [ask turtle i [ set liste_conf_epist lput ( 1 / 3 ) liste_conf_epist] ]
            [ask turtle i [ set liste_conf_epist lput 0 liste_conf_epist] ]
            set j (j + 1)
        ]
        set i (i + 1)
    ]
  ]
  if modeles_relations = "observer"
  [
    foreach sort turtles
    [
        set j 0
        foreach sort turtles
        [
            ifelse i = j
            [
              ifelse i = 0
              [ask turtle i [ set liste_conf_epist lput 0 liste_conf_epist] ]
              [ask turtle i [ set liste_conf_epist lput 1 liste_conf_epist] ]
            ]
            [
              ifelse i = 0
              [ask turtle i [ set liste_conf_epist lput (1 / (number_of_agents - 1)) liste_conf_epist] ]
              [ask turtle i [ set liste_conf_epist lput 0 liste_conf_epist] ]
            ]
            set j (j + 1)
        ]
        set i (i + 1)
    ]
  ]
  if modeles_relations = "random"
  [
    foreach sort turtles
    [
        let som 0
        set j 0
        foreach sort turtles
        [
          ifelse (random 100 / 100) < random_link_probability
          [
            let rand_number (random 100 / 100)
            ask turtle i [ set liste_conf_epist lput rand_number liste_conf_epist]
            set som (som + rand_number)
          ]
          [
            ask turtle i [ set liste_conf_epist lput 0 liste_conf_epist]
          ]
          set j (j + 1)
        ]
        let k 0
        ask turtle i
        [
          foreach liste_conf_epist
          [ [??1] ->
            ifelse som > 0
            [
              set liste_conf_epist (replace-item k liste_conf_epist (??1 / som))
            ]
            [
              set liste_conf_epist (replace-item i liste_conf_epist 1)
            ]
            set k (k + 1)

          ]
        ]
        set i (i + 1)
    ]
  ]
end 

;pour la matrice de confiance et les les données topologiques des tortues

to set-up-matrice

set matrice []
  let i 0
  foreach sort turtles
  [ [?1] ->
    ask ?1 [set matrice lput liste_conf_epist matrice]
  ]

set matrix matrix:from-row-list matrice

let j 0                                    ;ici la boucle pour fixer le indegree = la somme des poids des liens de confiance pointant sur chaque tortue
  while [j != number_of_agents]
  [let temp matrix:get-column matrix j
    ask turtle j [set indegree sum temp ]

  set j (j + 1)
  ]

  let k 0                                    ;ici la boucle pour fixer le nb_out_neighboors = le nombre d'agents directement accessibles à une totrtue donnée
  while [k != number_of_agents]
  [let l 0
    let temp2 0
    while [l != number_of_agents]
   [ ask turtle k [set temp2 ceiling (item l (item k matrice) ) + temp2   ]
    set l ( l + 1)
    ]
   ask turtle k [set nb_out_neighboors temp2]
  set k (k + 1)
  ]
end 

;où alternativement avec une boucle explicite (pour construire la pré-matrice comme liste de listes
;to set-up-matrice
;set matrice []
; let i 0
;  while [i != number_of_agents]
;  [
;    ask turtle i [set matrice lput liste_conf_epist matrice]
;
;  set i (i + 1)
;  ]
; end



;modelise les relations entre les agents par des flèches

to add_arrow
  let i 0
  let j 0
  let th 0

  foreach sort turtles
  [
    set j 0
    foreach sort turtles
    [
      ask turtle i
      [
          set th (item j liste_conf_epist)
          if th != 0 and i != j
          [ create-link-to turtle j [set thickness th / 4 ] ]
      ]
      set j (j + 1)
    ]
    set i (i + 1)
  ]
  ask links [ set shape "my_link" ]
end 

to go
  if ticks >= number-ticks [ stop ]
  update_ind_nat
  update_estime
  update_croyance
  update_perf
  determine_couple
  tick
end 



;mise à jour des croyances

to update_croyance
  let somme 0
  let temp 0
  let i 0
  let j 0
  let lst_croy_tmp []

  ifelse Nature_update
  [

  foreach sort turtles
 [
    set j 0
    set somme 0
    foreach sort turtles
    [
      ifelse i = j
      [
          ask turtle i [set somme (somme + ( (item i liste_conf_epist) * (last liste_estime_direct) ) ) ]
      ]
      [
          ask turtle i [ set temp (item j liste_conf_epist)]
          ask turtle j [ set somme ( somme + (temp * (last liste_croyance) ) ) ]
      ]
      set j (j + 1)
    ]
    set lst_croy_tmp lput somme lst_croy_tmp
    set i (i + 1)
  ]
  ]

[

  foreach sort turtles
 [
    set j 0
    set somme 0
    foreach sort turtles
    [
      ifelse i = j
      [
          ask turtle i [set somme (somme + ( (item i liste_conf_epist) * (last liste_croyance) ) ) ]
      ]
      [
          ask turtle i [ set temp (item j liste_conf_epist)]
          ask turtle j [ set somme ( somme + (temp * (last liste_croyance) ) ) ]
      ]
      set j (j + 1)
    ]
    set lst_croy_tmp lput somme lst_croy_tmp
    set i (i + 1)
  ]
  ]


  set i 0
  foreach sort turtles
  [ [?1] ->
    ask ?1 [
      set liste_croyance lput ( item i lst_croy_tmp) liste_croyance
    ]
    set i ( i + 1)
  ]
end 




;mise à jour des performances des agents

to update_perf
  let temp 0
  let somme 0
  let somme_expert 0
  let somme_layman 0
  let nb_exp 0
  let nb_lay 0

  foreach sort turtles
  [ [?1] ->
    ask ?1
    [
      set temp ( ((last liste_croyance) - parametre_a_estimer) * ((last liste_croyance) - parametre_a_estimer) )
      set liste_performence lput temp liste_performence
      set somme (somme + temp)
      ifelse expert
      [ set somme_expert (somme_expert + temp)
        set nb_exp (nb_exp + 1)]
      [ set somme_layman (somme_layman + temp)
        set nb_lay (nb_lay + 1)]
    ]
  ]
  set list_perf_glob lput (somme / number_of_agents) list_perf_glob
  if nb_exp > 0
  [ set list_perf_expert lput (somme_expert / nb_exp) list_perf_expert ]
  if nb_lay > 0
  [ set list_perf_lay lput (somme_layman / nb_lay) list_perf_lay ]
end 




;mise à jour de l'indice naturel des agents

to update_ind_nat
  let indice -1
  ask turtles
  [
      ifelse expert
      [
        while [ indice < 0 or indice > 1 ]
        [
          set indice random-normal parametre_a_estimer ecart_type_expert
        ]
        set liste_ind_nature lput indice liste_ind_nature
        set indice -1
      ]
      [
        while [ indice < 0 or indice > 1 ]
        [
          set indice random-normal parametre_a_estimer ecart_type_laymen
        ]
        set liste_ind_nature lput indice liste_ind_nature
      ]
  ]
end 




;mise à jour de l'estimation des agents

to update_estime
  foreach sort turtles
  [ [?1] ->
    ask ?1
    [
      set liste_estime_direct lput ( (sum [ liste_ind_nature ] of ?1) / (length liste_ind_nature) ) liste_estime_direct
    ]
  ]
end 





;artifice pour reporter dans le behaviour space le couple (dernière perf ; nb_out_neighboors)

to determine_couple
      let m 0                                    ; artifice pour pouvoir reporter facilement le couple (performance ; nb_out_neighboors) dans le bahaviour space
  while [m != number_of_agents]

   [ ask turtle m [set couple []]
     ask turtle m [set couple lput last liste_performence couple]
     ask turtle m [set couple lput nb_out_neighboors couple]
  set m (m + 1)
  ]
end 

to-report impact
  let val 0
let val2 0
if ticks > 0
[
foreach sort turtles [ [?1] ->
    set val [ last liste_estime_direct ] of ?1
    set val val - parametre_a_estimer
    set val val * val
    set val2 [ last liste_performence ] of ?1
    set val2 val - val2
    report val2
 ]
]
end