Belief Consolidation

extensions [nw]

globals[
  the-event
  num-original-beliefs
  population
]

turtles-own[ belief stubbornness tolerance ]

links-own[ friendship-strength]



;;Set up procedure

to setup
  ca
  
  set-default-shape turtles "circle"
  make-turtles  ;creates the turtles and the network 
  set population initial-num ;sets the global variable population
  set-event  ;This is what the intial belief is based off of
  
  ;;Have turtles initiall set beliefs to all 0s
  ask turtles [
    set belief [0 0 0]
    set-stubbornness/tolerance  
  ]

  give-turtles-belief the-event num-with-initial-belief  ;give a certain # of people an initial belief based on the the-event
  
  set-friendship-strengths
  
  color-turtles
  set-turtle-size
  
  reset-ticks
end 


;;Go procedure

to go

  ask turtles [
    
    if belief != [0 0 0] [  ;if the turtle has a belief
      ;If the turtle has neighbors, it interacts
      if count link-neighbors > 0 [
        let neighbor one-of link-neighbors ;;pick a neighbor
        spread-belief neighbor ;;spreads belief to neighbor, if the neighbor is similar, the friendship is strenghthened.
      ]
    ]
    
    ;Randomly might make a friend with a friend of a friend 
    make-random-friend-of-friend 
    
    ;Randomly might make a random friend 
    make-random-friend
    
    if count link-neighbors = 0 [ ;;if turtle has no friends, it automatically makes a new friend
      create-link-with one-of other turtles
    ]
  ] 
  
  ;Friendships weaken 
  ask links [
    set friendship-strength friendship-strength - friendship-decay
 
    if friendship-strength < 0 [
      die
    ]
  ]
  
  color-turtles
  set-turtle-size
  
  if spring? [
    spring-layout
  ]
  
  tick
end 




;************************************************************************************************
;SETUP CODE

;;sets the intial event. In this version of the model, the intial event is represented by
;A string of three numbers between 0 and 255 so that the turtles can display their 
;belief with their color

to set-event
  set the-event (list random 255 random 255 random 255)
  ask patches with ([pycor = max-pycor and pxcor < (min-pxcor + 3)]) [set pcolor the-event]
end 


;;Gives a number of turtles a new belief.

to give-turtles-belief [new-belief num-with-belief]
  
  ask one-of turtles [set belief new-belief ] 
  while [num-with-belief > count turtles with [belief = new-belief]   ] [
    ask one-of turtles with [belief = new-belief] [
      ask one-of link-neighbors [
        set belief new-belief
        ]
    ]
  ]
  
  ;add noise to new belief
  ask turtles with [belief = new-belief] [
    set belief (map[? + random-float noise] new-belief)
    trim-belief-between-1-255
  ]
end 

;A turtle gets a stubbornness and tolerance according to normal distribution around the values 
;chosen on the sliders. Stubbornness and tolerance are limited to the range 0 to 1

to set-stubbornness/tolerance
  
  set stubbornness random-normal ave-stubbornness stubbornness-std-dev
  if stubbornness > 1 [set stubbornness 1]
  if stubbornness < 0 [set stubbornness 0]
  
  set tolerance random-normal ave-tolerance tolerance-std-dev
  if tolerance > 1 [set tolerance 1]
  if tolerance < 0 [set tolerance 0]
end 

;;sets initial friendship strength

to set-friendship-strengths
  ask links [
    set friendship-strength initial-friendship-strength
  ]
end 


;************************************************************************************************
;GO CODE



;;Code to spread beliefs. In this version each tick a turtle picks one neighbor to interact
;with. The turtles average the beliefs and add some noise.

to spread-belief [neighbor]
  let my-belief belief      ;;new variable to hold my-belief
  let neighbor-belief [belief] of neighbor  ;;variable to hold neighbor's belief

  
  ifelse neighbor-belief = [0 0 0]  
  
  ;;If neighbor has no belief. I pass my belief to neighbor
  [  ask neighbor [
      set belief (map [? + random-float 2 * noise - noise] my-belief) 
      trim-belief-between-1-255]  
  ]
  
  [ ;;Second option of ifelse above: If the neighbor does have a belief. 
    ;If we can tolerate our differences, we average our beliefs, using stubborness as the weighting 
    
    let disagreement disagreement-between-2 my-belief neighbor-belief ;calculate the disagreement
    
    ;if tolerance is greater than disagreement, then share beliefs and strenthen friendship
    if disagreement < tolerance and disagreement < [tolerance] of neighbor [
      
      ifelse noise-effect = "averaged belief"  ;;the noise gets added after our beliefs are averaged. Noise still effects the beliefs of stubborn turtles
      
      [ set belief (map [ ( (?1 * stubbornness) + (?2 * (1 - stubbornness)) + random-float 2 * noise - noise )] my-belief neighbor-belief)
        trim-belief-between-1-255
        
        ask neighbor [
          set belief (map [ ( (?1 * stubbornness) + (?2 * (1 - stubbornness)) + random-float 2 * noise - noise)] neighbor-belief my-belief)
          trim-belief-between-1-255
        ]]
      
      ;;the noise gets added to the other turtle's belief, then averaged. Noise doesn't effet beliefs of stubborn turtles
      [ set belief (map [ ( (?1 * stubbornness) + ((?2  + random-float 2 * noise - noise)) * (1 - stubbornness))] my-belief neighbor-belief)
        trim-belief-between-1-255
        
        ask neighbor [
          set belief (map [ ( (?1 * stubbornness) + ((?2 + random-float 2 * noise - noise)) * (1 - stubbornness)) ] neighbor-belief my-belief)
          trim-belief-between-1-255
        ]]
      
      ;After sharing belief, strengthen friendship
      strengthen-friendship neighbor
    ]
    
  ]
end 


;Strengthens the friendship of two nodes that just interacted

to strengthen-friendship [neighbor]
  ask link-with neighbor [set friendship-strength friendship-strength + friendship-gain]
end 



;;Turtles make a new connection randomly

to make-random-friend
  if random-float 1 < (random-friend-prob) [
    let potential-friends other turtles with [not link-neighbor? myself]
    
    if any?(potential-friends) [ ;if there is such a friend 
      create-link-with one-of potential-friends [set friendship-strength initial-friendship-strength]
    ]
  ]
end 


;Turtles make a new friend with a friend of one of their friend's with a much higher probability than randomly 

to make-random-friend-of-friend
  if random-float 1 < (random-friend-prob * 3) [
    
    let friends-of-friends sort-by [count ?1 > count ?2]  [link-neighbors] of link-neighbors ;makes list of agentsets. one for the friends of each friend
    
    ;When there are 1 turtle agent sets in the list, it is only the asking turtle in it. They must be removed so turtle doesn't try to link with itself
    while [length friends-of-friends > 0 and count item (length friends-of-friends  - 1) friends-of-friends < 2] [ 
      set friends-of-friends but-last friends-of-friends
    ]
    
    ;If there are any friends of friends, make a friend with one of them
    if length friends-of-friends >= 1 [
      create-link-with one-of other (one-of friends-of-friends)
    ]
  ]
end 

;;Colors turtles according to their belief

to color-turtles
  ask turtles [
    ifelse belief = [0 0 0]
    [set color grey]
    [set color belief]
  ]
end 

;;Sizes turtles according to stubbornness

to set-turtle-size
  let max-stubbornness max([stubbornness] of turtles)
  ask turtles [
    ifelse stubbornness = 0
    [set size .5]
    [set size (.5 + stubbornness / max-stubbornness)]
    
    ifelse stubbornness = 1 
    [set shape "square"]
    [set shape "circle"]
  ]
end 

;;Adds a new belief to the world

to add-new-belief
  let new-belief (list random 255 random 255 random 255)
  
  
  ;Give turtles new belief
  ask one-of turtles [set belief new-belief ] 
  while [num-with-new-belief > count turtles with [belief = new-belief]   ] [
    ask one-of turtles with [belief = new-belief] [
      ask one-of link-neighbors [
        set belief new-belief
      ]
    ]
  ]

  ;The turtles with the new belief get new stubbornness and tolerances according to the sliders
  ask turtles with [belief = new-belief] [
    set-stubbornness/tolerance
  ]
  
  ;;Add noise to new belief
   ask turtles with [belief = new-belief] [
    set belief (map[? + random-float noise] new-belief)
    trim-belief-between-1-255
  ]
   
   
  color-turtles
  set-turtle-size
  
  ;increase the number of beliefs
  set num-original-beliefs num-original-beliefs + 1  
  ;display the new belief on upper left patches
  ask patches with ([pycor = max-pycor - num-original-beliefs and pxcor < (min-pxcor + 3)]) [set pcolor new-belief] 
end 



;If there is noise being added to the system, this checks to make sure the beliefs are within
;0 to 255 so that they can be displayed as a color

to trim-belief-between-1-255
  if noise > 0 [ ;;If noise is zero, don't bother checking
    let counter 0
    repeat 3 [
      if item counter belief > 255 [set belief replace-item counter belief 255]
      if item counter belief < 1 [set belief replace-item counter belief 1]
      set counter counter + 1
    ]
  ]
end 




;********************************************************************************
;Code to Generate Initial Network. Taken from the Network Externsion General Demo

;;Makes network according the type selected in the chooser

to make-turtles
  if network-type = "Random" [make-random-network]
  if network-type = "Preferential Attachment" [make-pref-attach-network]
  if network-type = "Small World" [make-small-world-network]
end 

to generate [ generator-task ]
  ; we have a general "generate" procedure that basically just takes a task 
  ; parameter and run it, but takes care of calling layout and update stuff
  set-default-shape turtles "circle"
  run generator-task
  layout-once
  ;update-plots
end 

to make-random-network
  generate task [ nw:generate-random turtles links initial-num connexion-prob ]
end 

to make-pref-attach-network
  generate task [ nw:generate-preferential-attachment turtles links initial-num ]
end 

to make-small-world-network
  generate task [ nw:generate-small-world turtles links sqrt(initial-num) sqrt(initial-num) 2 true] 
end 

to redo-layout [ forever? ]
  if layout = "radial" and count turtles > 1 [
    layout-radial turtles links ( max-one-of turtles [ count my-links  ] )
  ]
  if layout = "spring" [
    let factor sqrt count turtles
    if factor = 0 [ set factor 1 ]
    repeat ifelse-value forever? [ 1 ] [ 50 ] [
      layout-spring turtles links (1 / factor) (150 / factor) (1.5 / factor)
      display
      if not forever? [ wait 0.005 ]
    ]
  ]
  if layout = "circle" [
    layout-circle sort turtles max-pxcor * 0.9
  ]
  if layout = "tutte" [
    layout-circle sort turtles max-pxcor * 0.9
    repeat 10 [
      layout-tutte max-n-of (count turtles * 0.5) turtles [ count my-links ] links 12
    ]
  ]
end 

to layout-once
  redo-layout false
end 

to spring-layout
  let factor sqrt count turtles
   if factor = 0 [ set factor 1 ]
   layout-spring turtles links (2 / factor) (70 / factor) (.5 / factor)
end 


;********************************************************************************************
;Reporter Code. Reporters on agreement between nodes

;;A measure of the level of agreement among all the turtles regarding the first part of
;the belief. (the first number in the belief list)

to-report B0-disagreement
  let aveB0 sum( [item 0 belief] of turtles with [ (belief != [0 0 0])]) / population
  let disagreement sum(  [abs(item 0 belief - aveB0)] of turtles with [ (belief != [0 0 0])]) / (population * aveB0)
  report disagreement
end 

to-report B1-disagreement
  let aveB1 sum( [item 1 belief] of turtles with [ (belief != [0 0 0])]) / population
  let disagreement sum(  [abs(item 1 belief - aveB1)] of turtles with [ (belief != [0 0 0])]) / (population * aveB1)
  report disagreement
end 

to-report B2-disagreement
  let aveB2 sum( [item 2 belief] of turtles with [ (belief != [0 0 0])]) / population
  let disagreement sum(  [abs(item 2 belief - aveB2)] of turtles with [ (belief != [0 0 0])]) / (population * aveB2)
  report disagreement
end 

to-report disagreement-w-initial-event
  let disagreement-0 abs(item 0 belief - item 0 the-event) / 254
  let disagreement-1 abs(item 1 belief - item 1 the-event) / 254
  let disagreement-2 abs(item 2 belief - item 2 the-event) / 254
  report (disagreement-0 + disagreement-1 + disagreement-2) / 3
end 

to-report ave-disagreement-w-initial-event
  report mean([disagreement-w-initial-event] of turtles)
end 

to-report disagreement-between-2 [t1-belief t2-belief]
  let disagreement-0 abs(item 0 t1-belief - item 0 t2-belief) / 254
  let disagreement-1 abs(item 1 t1-belief - item 1 t2-belief) / 254
  let disagreement-2 abs(item 2 t1-belief - item 2 t2-belief) / 254
  report (disagreement-0 + disagreement-1 + disagreement-2) / 3
end