Collective Equilibrium Selection via Pure Coordination

globals [
  this-cluster
  infinity                             ;; a very large number.
  tick-counter
  endogenous?
  payoff

  my-palette
]


turtles-own [
  strategy

  cluster

  pos-x
  pos-y
  node-clustering-coefficient


]

links-own
[
  rewired?                    ;; keeps track of whether the link has been rewired or not
]

to go
end 

to construct-agent
  ;; turtles-own agent constructor

  set shape "circle"
  ;set label who
end 


;;;;;;;;;;;;;;;;;;;;;;;;
;;; Setup Procedures ;;;
;;;;;;;;;;;;;;;;;;;;;;;;

to setup
  clear-all
  set endogenous? true
  set my-palette [ [255 127 39] [255 0 0] [255 255 0] [0 255 0] [0 64 128] [0 255 255] [128 128 255] [128 0 128] [255 0 128] [128 128 0] [0 0 0] [133 122 122]
  [255 127 39] [255 0 0] [255 255 0] [0 255 0] [0 64 128] [0 255 255] [128 128 255] [128 0 128] [255 0 128] [128 128 0] [0 0 0] [133 122 122] ]


  ask patches [ set pcolor white ]

  if topology = "Scale-Free" [ create-hubspoke ]
  if topology = "Random Permute" [ create-ringlat permute-all
      layout-circle (sort turtles) max-pxcor - 1
  ]
  if topology = "Square Lattice" [ create-square-lattice ]
  if topology = "Ring Lattice" [ create-ringlat ]
  if topology = "ER Graph" [ setup-erdos-renyi ]
  if topology = "Small World" [ rewire-all ]
  if topology = "Star" [ create-star ]
  if topology = "Full" [ crt N [ construct-agent ] ask turtles [ create-links-with other turtles ] layout-circle turtles 10 ]






  let num-solutions n-solutions
  if num-solutions < 1 [ set num-solutions 9999999999 ]

  ifelse endogenous?
  [
    if num-solutions > N  [ set num-solutions N ]
    ask turtles [ set strategy 0 set label strategy ]
    let i 0
    ask n-of num-solutions turtles [
      set i i + 1
      set strategy i
    ]
  ]
  [

    ask turtles [
      set strategy (random num-solutions) + 1
    ]
  ]

  let all-strategies [strategy] of turtles

  let need-zero? min all-strategies = 0

  ask turtles [
    set strategy ( position strategy sort remove-duplicates all-strategies )
    set label strategy
  ]

  set payoff n-values count-unique [ random-payoff ]
  ifelse need-zero? [ set payoff replace-item 0 payoff -99999999 ]
  [
    ask turtles [ set strategy strategy + 1 set label strategy ]
    set payoff fput -99999999 payoff
  ]

  reset-ticks
end 

to run-step

  ask one-of turtles with [ strategy = 0 or strategy != update-strategy ] [
    set strategy update-strategy
    set label strategy
    set-color-ng strategy
  ]

  tick
end 

to-report update-strategy

  ;; NEED TO DEFINE THIS LIST
  ;; because the dynamic definition is a randomized order!

  let worldview [strategy] of link-neighbors

  let option-payoff ( map
    [ [?1] -> (occurrences ?1 worldview) * (item ?1 payoff) ]
    (remove-duplicates worldview)
  )


  report item ( position (max option-payoff) option-payoff ) (remove-duplicates worldview)
end 


;; creates a new lattice

to create-ringlat
  crt N [ set color black construct-agent ]
  wire-ringlat
end 

to wire-ringlat
  layout-circle (sort turtles) max-pxcor - 1

  layout-circle (sort turtles with [ who mod 2 = 0] ) max-pxcor - 4
  ;; iterate over the turtles
  let ni 0
  while [ni < count turtles]
  [
    ;; make edges with the next two neighbors
    ;; this makes a lattice with average degree of 4
    let z 1
    while [z <= floor (k / 2)]
    [
      ask turtle ni [ create-link-with turtle ((ni + z) mod count turtles) [ set rewired? false ] ]
      set z z + 1
    ]
    set ni ni + 1
  ]
end 















;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; SCALE-FREE Procedures ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; used for creating a new node

to make-node [old-node]
end 

;; This code is the heart of the "preferential attachment" mechanism, and acts like
;; a lottery where each node gets a ticket for every connection it already has.
;; While the basic idea is the same as in the Lottery Example (in the Code Examples
;; section of the Models Library), things are made simpler here by the fact that we
;; can just use the links as if they were the "tickets": we first pick a randaom link,
;; and than we pick one of the two ends of that link.

to-report find-partner
  report [one-of both-ends] of one-of links
end 

;;;;;;;;;;;;;;;;;
;;; SF Layout ;;;
;;;;;;;;;;;;;;;;;

;; resize-nodes, change back and forth from size based on degree to a size of 1

to resize-nodes
  ifelse all? turtles [size <= 1]
  [
    ;; a node is a circle with diameter determined by
    ;; the SIZE variable; using SQRT makes the circle's
    ;; area proportional to its degree
    ask turtles [ set size sqrt count link-neighbors ]
  ]
  [
    ask turtles [ set size 1 ]
  ]
end 

to layout
  ;; the number 3 here is arbitrary; more repetitions slows down thea
  ;; model, but too few gives poor layouts
  repeat 3 [
    ;; the more turtles we have to fit into the same amount of space,
    ;; the smaller the inputs to layout-spring we'll need to use
    let factor sqrt count turtles
    ;; numbers here are arbitrarily chosen for pleasing appearance
    layout-spring turtles links (1 / factor) (7 / factor) (( 2 * k) / factor)
    display  ;; for smooth animation
  ]
  ;; don't bump the edges of the world
  let x-offset max [xcor] of turtles + min [xcor] of turtles
  let y-offset max [ycor] of turtles + min [ycor] of turtles
  ;; big jumps look funny, so only adjust a little each time
  set x-offset limit-magnitude x-offset 0.1
  set y-offset limit-magnitude y-offset 0.1
  ask turtles [ setxy (xcor - x-offset / 2) (ycor - y-offset / 2) ]
end 

to-report limit-magnitude [number limit]
  if number > limit [ report limit ]
  if number < (- limit) [ report (- limit) ]
  report number
end 


;  Scale-Free Code Adapted From NetLogo library item
;  that is Copyright 2005 Uri Wilensky.
;  see info tab for full copyright info.

to setup-erdos-renyi

  ;; Make a circle of turtles
  create-turtles N [ construct-agent ]
  layout-circle turtles (max-pxcor - 1)

  let success? false
  let count-tries 0
  while [ not success? ] [
    ask links [ die ]
    ;; Now give each pair of turtles an equal chance
    ;; of creating a link
    ask turtles [
      ;; we use "self > myself" here so that each pair of turtles
      ;; is only considered once
      create-links-with turtles with [self > myself and
        random-float 1.0 < p ]
    ]

    set success? ( item 0 identify-clusters = 1 )
    set count-tries count-tries + 1
    if ( count-tries > 1000 ) [ set success? true print "couldn't make connected network!  try different parameters!" ]

  ]
end 


;; clusters code adapted from "Dissemination of Culture" by ???
;; see info tab for full copyright info

to-report identify-clusters
  let max-cluster 0
  let num-clusters 0

  let seed one-of turtles
  ask turtles [ set cluster nobody ]
  while [seed != nobody] [
    ask seed [
      set cluster self
      set num-clusters num-clusters + 1
      set this-cluster 1
      grow-cluster
    ]
    if this-cluster > max-cluster [ set max-cluster this-cluster]
    set seed one-of turtles with [cluster = nobody]
  ]
  report list num-clusters max-cluster
end 

to grow-cluster

    ask link-neighbors with [cluster = nobody] [
      if cluster = nobody [ set this-cluster this-cluster + 1 ]
      set cluster [cluster] of myself
      grow-cluster
    ]
end 



;;  small-worlds code adapted by material
;;  Copyright 2005 Uri Wilensky.
;;  see info tab for full copyright info.

to rewire-all

  create-ringlat

  ;; set up a variable to see if the network is connected
  let success? false

  ;; if we end up with a disconnected network, we keep trying, because the APL distance
  ;; isn't meaningful for a disconnected network.
  let count-tries 0
  while [not success?] [
    ;; kill the old lattice, reset neighbors, and create new lattice
    ask links [ die ]
    wire-ringlat
;   set number-rewired 0

    ask links [

      ;; whether to rewire it or not?
      if (random-float 1) < p
      [
        ;; "a" remains the same
        let node1 end1
        ;; if "a" is not connected to everybody
        if [ count link-neighbors ] of end1 < (count turtles - 1)
        [
          ;; find a node distinct from node1 and not already a neighbor of node1
          let node2 one-of turtles with [ (self != node1) and (not link-neighbor? node1) ]
          ;; wire the new edge
          ask node1 [ create-link-with node2 [ set color cyan  set rewired? true ] ]

;          set number-rewired number-rewired + 1  ;; counter for number of rewirings
          set rewired? true
        ]
     ]
      ;; remove the old edge
      if (rewired?)
      [
        die
      ]
    ]

    set success? ( item 0 identify-clusters = 1 )
    set count-tries count-tries + 1
    if ( count-tries > 1000 ) [ set success? true print "couldn't make connected network!  try different parameters!" ]
  ]
end 

to rewire-one

  ;; make sure num-turtles is setup correctly else run setup first
  if count turtles != N [
    setup
  ]


  let potential-edges links with [ not rewired? ]
  ifelse any? potential-edges [
    ask one-of potential-edges [
      ;; "a" remains the same
      let node1 end1
      ;; if "a" is not connected to everybody
      if [ count link-neighbors ] of end1 < (count turtles - 1)
      [
        ;; find a node distinct from node1 and not already a neighbor of node1
        let node2 one-of turtles with [ (self != node1) and (not link-neighbor? node1) ]
        ;; wire the new edge
        ask node1 [ create-link-with node2 [ set color cyan  set rewired? true ] ]


        ;; remove the old edge
        die
      ]
    ]
  ]
  [ user-message "all edges have already been rewired once" ]
end 

to-report percent-saturated
  report ((count turtles with [color = red ] ) / (count turtles))
end 

to create-square-lattice
  let lat-width (closest-factors N)
  let lat-height (N / lat-width)
  let width max-pxcor - min-pxcor
  let height max-pycor - min-pycor
  let left-edge min-pxcor + 0.5
  let top-edge min-pycor + 0.5
  let slot-width width / lat-width
  let slot-height height / lat-height


  ;; this sets the order of neighbor addition to easily create a square lattice
  ;; with any degree (up to the length of the map)
  let square-neighbor-map [ [1 0] [0 1] [-1 0] [0 -1] [1 1] [-1 1] [-1 -1] [1 -1] ]
  if (k > length square-neighbor-map) [ print "Square lattice degree too large!  Check code." stop ]

  print lat-width

  let xi 0
  while [ xi < lat-width ] [
    let yi 0
    while [ yi < lat-height ] [
      crt 1 [
        set pos-x xi
        set pos-y yi
        setxy ( (xi * slot-width) + left-edge) ( (yi * slot-height) + top-edge)
        construct-agent
      ]
      set yi yi + 1
    ]
    set xi xi + 1
  ]
  ask turtles [
    let ni 0
    while [ni < k] [
      let target-pos-x pos-x + item 0 item ni square-neighbor-map
      let target-pos-y pos-y + item 1 item ni square-neighbor-map
      if (target-pos-x > lat-width) [ set target-pos-x target-pos-x - lat-width ]
      if (target-pos-y > lat-height) [ set target-pos-y target-pos-y - lat-height ]
      if (target-pos-x < 0 ) [ set target-pos-x target-pos-x + lat-width ]
      if (target-pos-y < 0 ) [ set target-pos-y target-pos-y + lat-height ]
      create-links-with turtles with [ pos-x = target-pos-x and pos-y = target-pos-y ]
      set ni ni + 1
    ]
  ]
end 

to-report closest-factors [ num ]
  let greatestEdge 1
  let i 1
  while [ i < num ] [
    if(num mod i = 0) [
      if abs (greatestEdge - (num / greatestEdge) ) > abs ( i - (num / i) ) [
        set greatestEdge i
      ]
    ]
    set i i + 1
  ]
  report greatestEdge
end 

to create-hubspoke

  set-default-shape turtles "circle"
  ;; make the initial network of two turtles and an edge
  crt 1 [ construct-agent ]        ;; first node, unattached
  let mi 1
  while [ mi < m ][
    crt 1 [
      let counter 1
      repeat mi [
        create-link-with turtle (mi - counter)
        set counter counter + 1
      ]
      construct-agent
    ]
    set mi mi + 1
  ]      ;; second node, attached to first node

  repeat (N - m) [ add-link ]

  ask turtles with [who <= 5] [
    while [ count link-neighbors < m ] [
      let old-node find-partner
      while [ [who] of old-node = who ] [ set old-node find-partner ]
      create-link-with old-node
      ;; position the new node near its partner
      move-to old-node
      fd 8
    ]

  ]
end 

to add-link
  ;; new edge is green, old edges are gray
  ask links [ set color gray ]
  make-node find-partner         ;; find partner & use it as attachment
                                 ;; point for new node

  crt 1
  [
    repeat m [
      let old-node find-partner
      while [ ([who] of old-node = who) OR (length filter [ [?1] -> ?1 = [who] of old-node ] [who] of link-neighbors != 0) ]
      [ set old-node find-partner ]
      create-link-with old-node
      ;; position the new node near its partner
      move-to old-node
      fd 8
    ]
    construct-agent
  ]
end 

to permute

  let success false

  while [ success = false ]
  [
     let graphset sort link-set links

     let permutewith random count link-set links
     let permuter random count link-set links

     let abort false

     if [end1] of item permuter graphset = [end1] of item permutewith graphset [ set abort true ]
     if [end2] of item permuter graphset = [end1] of item permutewith graphset [ set abort true ]
     if [end2] of item permutewith graphset = [end1] of item permuter graphset [ set abort true ]
     ask [end1] of item permuter graphset
     [
       if link-neighbor? [end2] of item permutewith graphset [ set abort true ]
     ]

     ask [end1] of item permutewith graphset
     [
       if link-neighbor? [end2] of item permuter graphset [ set abort true ]
     ]

     if abort = false [
          ask [end1] of item permuter graphset    [ create-link-with [end2] of item permutewith graphset ]

          ask [end1] of item permutewith graphset [ create-link-with [end2] of item permuter graphset ]


          ask item permuter graphset [ die ]

          ask item permutewith graphset [ die ]
          set success true
     ]

  ]
end 

to permute-all
  let z 0
  while [z < ((count turtles) * k * 3)]
  [
    permute
    set z z + 1
  ]
end 

to labels-from-list [ label-list color-list ]
  let i 0
  while [i < length label-list] [
    ask turtle i [
      set label item i label-list
      set label-color item i color-list
    ]

    set i i + 1
  ]
end 

to-report clustering-coefficient
  let global-clustering-coefficient 0
  ifelse all? turtles [count link-neighbors <= 1]
  [
    ;; it is undefined
    ;; what should this be?
    set global-clustering-coefficient -1
  ]
  [
    let total 0
    ask turtles with [ count link-neighbors <= 1]
      [ set node-clustering-coefficient "undefined" ]
    ask turtles with [ count link-neighbors > 1]
    [
      let hood link-neighbors
      set node-clustering-coefficient (2 * count links with [ in-neighborhood? hood ] /
                                         ((count hood) * (count hood - 1)) )
      ;; find the sum for the value at turtles
      set total total + node-clustering-coefficient
    ]
    ;; take the average
    set global-clustering-coefficient total / count turtles with [count link-neighbors > 1]
  ]
  report global-clustering-coefficient
end 

to-report in-neighborhood? [ hood ]
  report ( member? end1 hood and member? end2 hood )
end 

to-report graph-density
  set N count turtles
  report ( (2 * count links) / ( N * (N - 1) ) )
end 

to-report random-lognormal [ mymean mystd ]
      let varx ( mystd ^ 2)
      let ess sqrt( ln(1 + (varx / ( mymean ^ 2))) )
      let mu ln(mymean) - ((1 / 2) * (ess ^ 2))
      report exp ( (mu + (ess * random-normal 0 1)) )
end 

to-report random-payoff
  report random-lognormal 100 50
end 

to-report occurrences [x the-list]
  report reduce
  [ [?1 ?2] -> ifelse-value (?2 = x) [?1 + 1] [?1] ] (fput 0 the-list)
end 

to set-color-ng [ value ]
  ifelse  N > 24 [ set color value ]
  [
    let this-color value - 1
    set color item this-color my-palette
    if this-color < 12 [ set shape "circle" ]
    if this-color >= 12 [ set shape "x" ]
  ]
end 

to create-star
  crt N [ construct-agent ]
  ask turtles with [ who < k ] [ create-links-with turtles with [ who >= k ] ]
  ask turtles with [ who >= k ] [ create-links-with turtles with [ who < k ] ]

  layout-circle turtles 10
end 

to-report count-unique
report  length remove-duplicates [strategy] of turtles
end