;; define new variables to be used by the agents
globals [
cntbig
cntlittle
cntbirds
cntturtles
cumbig
cumlittle
cycle
generation
proportion-little
cumrat
cumpropbig
cumproplittle
growthratebig
growthratelittle
littledot
bigdot
cntbigold
cntlittleold
]
patches-own
[
unique-number
]
; define two breeds of birds
breed [ big_bird ]
breed [ little_bird ]
to setup
ca
setup-patches
setup-birds
setup-plots
end
to setup-patches
; set all patches white and assign a unique, random number between 0 and 1
ask patches
[set unique-number (random-float 1)]
ask patches
[set pcolor white]
; Create nesting sites. Turn a proportion (beta) of the patches green.
;The larger the beta, the more room at the top of the unit number line
; add 0.0000001 so there is no overlap of a patch with a unique number of 0.5 when beta = 0.5 and delta = 0.5
ask patches
[if (unique-number) >= 1 - beta + 0.0000001
[ set pcolor green]]
; Create Tar pits. Turn a proportion (delta) of the patches black.
ask patches
[if (unique-number) <= delta - .0000001
[set pcolor black]]
; make the home patch white in all cases
ask (patch 0 0) [set pcolor white]
end
to setup-birds
cct initial-birds
[
set generation 1
; Birds start at home patch.
; scatter the birds around the screen
setxy (random-float world-width)
(random-float world-height)
; set the mix of big_birds and little_birds based on proportion_big slider
; start with a population of only little birds so slider is set at 0
ifelse (random-float 1.0 < proportion_big)
[
set breed big_bird
set color red
set shape "big_bird"
]
[
set breed little_bird
set color blue
set shape "little_bird"
]
]
end
to setup-plots
clear-all-plots
set-current-plot "num. big (red) and little (blue)"
; this title must exactly match the title given the graph you set up with the tool-bar.
auto-plot-on
; this allows constant re-scaling
set-plot-x-range 0 50
create-temporary-plot-pen "little"
set-plot-pen-color blue
create-temporary-plot-pen "big"
set-plot-pen-color red
set-current-plot "prop big and little"
auto-plot-on
set-plot-x-range 0 50
set-plot-y-range 0 1
create-temporary-plot-pen "prop_big"
set-plot-pen-color red
create-temporary-plot-pen "prop_little"
set-plot-pen-color blue
; create points of reference on graph
create-temporary-plot-pen "one"
set-plot-pen-color black
create-temporary-plot-pen "onethird"
set-plot-pen-color black
create-temporary-plot-pen "twothird"
set-plot-pen-color black
end
;go is a forever button, so repeats infinitely
to go
repro
run-count ; calculate the cumulative proportion of big and little birds.
move-birds
; periodically, reduce the population to the carrying-capacity,
;to avoid excess slow-down of model
grim-reaper
do-plots
end
; Code for turtles is odd in order to make them wait their turn,
;and randomly decide the order of turtles executing the commands each generation.
to move-birds
foreach shuffle values-from turtles [self]
[ask ?
[
if (pcolor = white)
[rt (random-int-or-float 360 ) fd random 100 ]
]
]
end
to repro
; randomly move until hit a green or a black patch.
; Each bird takes their turn, reacts to where they land and clones or dies or jumps.
; If clone, send progeny to home patch
; where they all stack up waiting for everyone else to take their turn.
; jump between 0 and 100 to avoid clustering around nesting sites if only move forward 1
; hatch 2 then die equates to a doubling of that bird type
foreach shuffle values-from turtles [self]
[ask ?
[set heading 0
; have birds react to patch color, then move
; All die if land on a black patch
if (pcolor = black)
[die]
; If only one bird is on a green patch,
; base-line birthrate of one bird becomes two is used.
if (pcolor = (green)) and (count (turtles-here) = 1)
[hatch 2 [rt (random-int-or-float 360 ) home
set generation (generation + 1) ]
die
]
; if more than 2 birds are on a green patch,
; base-line birthrate of one bird becomes two is used
; to be consistent with multiple tar pit deaths.
if (pcolor = (green)) and (count (turtles-here) > 2)
[hatch 2 [rt (random-int-or-float 360 ) home
set generation (generation + 1) ]
die
]
; If exactly 2 birds are on a green patch,
;Hatch two for base-line birthrate
; PLUS hatch additional based on the "meet" slider values
; Payoff to big bird when big meet big BmeetB
if (pcolor = (green)) and (count (big_bird-here) = 2)
[hatch 2 + BmeetB [rt (random-int-or-float 360 ) home
set generation (generation + 1) ]
set pcolor yellow die
]
; If one is left there, have them return patch to green, then die after send offspring home.
if (pcolor = (yellow)) and (count (big_bird-here) = 1)
[hatch 2 + BmeetB [rt (random-int-or-float 360 ) home
set generation (generation + 1) ]
set pcolor green die
]
; Payoff to little when little meet little LmeetL
if (pcolor = (green)) and (count (little_bird-here) = 2)
[hatch 2 + LmeetL [rt (random-int-or-float 360 ) home
set generation (generation + 1) ]
set pcolor pink die
]
; If one is left there, have them return patch to green, then die after send offspring home.
if (pcolor = (pink)) and (count (little_bird-here) = 1)
[hatch 2 + LmeetL [rt (random-int-or-float 360 ) home
set generation (generation + 1) ]
set pcolor green die
]
; cross breed meet
; Payoff to little when little meets big LmeetB
if (breed = little_bird) and (pcolor = (green)) and (count (big_bird-here) = 1)
and (count (little_bird-here) = 1)
[hatch 2 + LmeetB [rt (random-int-or-float 360 ) home
set generation (generation + 1) ]
set pcolor orange die
]
; Payoff to big bird when big meets littledove BmeetL
if (breed = big_bird) and (pcolor = (green)) and (count (little_bird-here) = 1)
and (count (big_bird-here) = 1)
[hatch 2 + BmeetL [rt (random-int-or-float 360 ) home
set generation (generation + 1) ]
set pcolor orange die
]
; now two questions when have one turtle left.
if (breed = little_bird) and (pcolor = (orange)) and (count (turtles-here) = 1)
[hatch 2 + LmeetB [rt (random-int-or-float 360 ) home
set generation (generation + 1) ]
set pcolor green die
]
;now ask big bird
if (breed = big_bird) and (pcolor = (orange)) and (count (turtles-here) = 1)
[hatch 2 + BmeetL [rt (random-int-or-float 360 ) home
set generation (generation + 1) ]
set pcolor green die
]
]
]
end
; Run Grim Reaper. This routine is derived from another NetLogo model, copyright Wilensky, U. (1998).
; NetLogo Simple Birth Rates model.
; http://ccl.northwestern.edu/netlogo/models/SimpleBirthRates.
; Center for Connected Learning and Computer-Based Modeling,
; Northwestern University, Evanston, IL.
;; kill turtles in excess of carrying capacity
;; note that hawks and doves have equal probability of dying; however, if there are more of one,
; more of that breed will die each time grim reaper engages.
to grim-reaper
locals [ num-turtles chance-to-die ]
set num-turtles count turtles
foreach shuffle values-from turtles [self]
[ask ?
; Bypass grim reaper if have not reached carrying capacity
[if num-turtles <= carrying-capacity
[ stop ]
set chance-to-die (num-turtles - carrying-capacity) / num-turtles
; random sequence of grim reaper, so all turtles shuffle their values so sequence changes each time
if random-float 1.0 < chance-to-die
[ die ]
]
]
end
to run-count
; use to calculate cumulative stats for big, little birds
set cntbig count (big_bird)
set cntlittle count (little_bird)
set cntturtles count (turtles)
if generation > cycle [set littledot count (little_bird)]
; exit loop if already calculated proportion to avoid repeated counting
if generation = cycle
[stop]
; incrementally increase the cumulative number of hawks, doves
set cumbig cumbig + cntbig
set bigdot cntbig - cntbigold
set littledot cntlittle - cntlittleold
set cumlittle cumlittle + cntlittle
set cycle generation
set cumpropbig (cumbig) / (cumlittle + cumbig)
set cumproplittle (cumlittle) / (cumlittle + cumbig)
if cntbig > 0
[set growthratebig (bigdot / cntbig)]
if cntlittle > 0
[set growthratelittle (littledot / cntlittle) ]
set cntbigold cntbig
set cntlittleold cntlittle
end
to do-plots
set-current-plot "num. big (red) and little (blue)"
create-temporary-plot-pen "big"
plot count big_bird
create-temporary-plot-pen "little"
plot count little_bird
set-current-plot "prop big and little"
create-temporary-plot-pen "prop_big"
plot ((count big_bird) / ((count little_bird) + (count big_bird)+ 0.00001))
; 0.0000001 is added to avoid error of divide by 0 when a type dies out
create-temporary-plot-pen "prop_little"
plot ((count little_bird) / ((count little_bird) + (count big_bird)+ 0.000001))
; create reference lines on the graph
create-temporary-plot-pen "one"
plot ((count turtles)/(count turtles + 0.00001))
create-temporary-plot-pen "onethird"
plot ((count turtles)/((3)*(count turtles + 0.0000001)))
create-temporary-plot-pen "twothird"
plot ((2)*(count turtles)/((3)*(count turtles + 0.00001)))
end
@#$#@#$#@
GRAPHICS-WINDOW
420
11
745
357
17
17
9.0
1
10
1
1
1
0
1
1
1
-17
17
-17
17
CC-WINDOW
5
387
754
482
Command Center
0
BUTTON
3
42
58
75
NIL
setup
NIL
1
T
OBSERVER
T
NIL
BUTTON
63
42
118
75
NIL
go
T
1
T
OBSERVER
T
NIL
PLOT
213
251
479
373
num. big (red) and little (blue)
time
count
0.0
655.0
0.0
100.0
true
false
PLOT
10
221
210
371
prop big and little
time
proportion
0.0
655.0
0.0
1.0
true
false
SLIDER
2
74
105
107
initial-birds
initial-birds
0
500
200
1
1
NIL
MONITOR
310
41
411
90
count birds
cntturtles
0
1
SLIDER
-1
107
146
140
proportion_big
proportion_big
0
1.0
0.0
0.01
1
NIL
SLIDER
128
41
300
74
beta
beta
0
0.5
0.25
0.01
1
NIL
SLIDER
128
74
300
107
delta
delta
0
0.5
0.25
0.01
1
NIL
SLIDER
10
147
102
180
BmeetB
BmeetB
0
10
0
1
1
NIL
SLIDER
108
159
215
192
BmeetL
BmeetL
0
10
0
1
1
NIL
SLIDER
13
189
105
222
LmeetB
LmeetB
0
10
0
1
1
NIL
SLIDER
108
193
217
226
LmeetL
LmeetL
0
10
0
1
1
NIL
MONITOR
286
177
425
226
cumulative prop big
cumpropbig
3
1
MONITOR
285
116
421
165
cumulative prop little
cumproplittle
3
1
SLIDER
132
10
304
43
carrying-capacity
carrying-capacity
0
1000
1000
1
1
1
@#$#@#$#@
WHAT IS IT?
A two-player, replicator dynamic model of evolutionary game theory is simulated in this program. The model contains two breeds of birds that randomly play a simultaneous game with other birds. Each breed is "hard-wired" to play their breed's strategy. The model allows the user to set different payoffs for each of the four possible matches between breeds. These payoffs determine each type's reproductive success. The model also allows the user to change the overall birth and death rate for all birds in the simulation. This allows a complete simulation of evolutionary models that include background levels of fitness as well as payoffs based on cooperation and competition.
HOW IT WORKS
The simulation contains two breeds of birds, Little birds and Big birds. Each breed is hard-wired to play their breed’s strategy (a polymorphic population). Birds can fly in any direction and randomly fly a distance between one and 100 patches. The birds live in a swamp that consists of random black patches (tar pits), random green patches (nesting sites) and random white patches (neutral sand). Birds die if they land on a black patch, and they breed via cloning if they land on a green patch. After landing on a patch, the bird waits for all other birds to finish that round of movement before they react to their patch.
'
"Setup" randomly scatters white, black, and green patches around the swamp based on the delta and beta settings. "Setup" also randomly scatters the initial number of birds around the swamp in the proportion determined by the "proportion big" setting.
'
"Go" is clicked after setup to initiate the simulation. Clicking "Go" again pauses the simulation. If initial sliders are changed, "setup" needs to be re-clicked to reflect the changes.
'
The swamp's carrying capacity limit is determined by the "carrying capacity" slider. If the population of birds exceeds this carrying capacity, disease and insufficient food will cause birds to randomly die off even if they don't land on a tar pit. This population limit highlights the importance of the "sufficiently large population" assumption associated with the replicator dynamic. If carrying capacity is set too low, the random nature of the simulation may cause a population to unexpectedly die out. If carrying capacity is set too high, the simulation will begin to run at a very slow speed, especially in older computers. In most situations, users should set carrying-capacity as high as possible to avoid unexpected population demise.
'
The "beta" slider determines the proportion of the swamp that will be green nesting sites. The initial setting of 0.25 means one in four patches will be green. This proportion is equivalent to a 25% base-line birth rate in the simulation because any bird landing on a green patch duplicates itself.
'
The "delta" slider determines the proportion of the swamp that will be black tar pits. The initial setting of 0.25 means one in four patches will be black. This proportion is equivalent to a 25% base-line death rate in the simulation because any bird landing on a black patch dies. If "beta" and "delta" are both set at 0.5, the swamp will be set up with an equal number of green and black patches and the only white patch will be the home patch in the middle of the swamp.
'
The background level of fitness for the simulation is a function of the birth-rate minus the death-rate. If birth rate (beta) is set to be greater than death rate (delta), birds will die out. If "beta" is set to be less than "delta", birds should reach carrying capacity. If beta is set equal to delta, the outcome is random and the population will randomly walk away from the initial number of birds, eventually reaching carrying capacity, and/or eventually dying out. These results require all four of the "meet" sliders to be set to zero. This eliminates the additional cloning that is used to create payoffs later in the exercise.
'
The "initial-birds" slider determines the starting number of birds. The "proportion_big" slider determines the initial mix of big and little birds. For example, if "initial-birds" is set at 100, and "proportion_big" is set at 0.25, the starting population will consist of 25 big and 75 little birds randomly scattered around the swamp.
'
If a bird lands on a green, nesting patch, it will create two clones of itself, then die, resulting in a net increase of one of that breed. If exactly two birds are on a green patch, there is the possibility of additional cloning which is used to create payoffs for the two player game. The number of additional clones is determined by the four "meet" sliders which define payoffs for all four player combinations found in a simultaneous, two player game.
'
The "BmeetB" slider determines the additional payoff received by each of (exactly) two Big birds that are on a green patch. The "BmeetL" slider determines the additional payoff received by a Big bird that encounters a Little bird on a green patch when there are exactly two birds on a green patch. The "LmeetB" slider determines the additional payoff received by a Little bird that encounters a Big bird on a green patch when there are exactly two birds on a green patch. The "LmeetL" slider determines the additional payoff received by each of (exactly) two Little birds that are on a green patch. For example, if a Big and a Little bird are on the same green patch, the Big bird can be assigned a 5 payoff and the Little bird a 1 payoff by setting the "BmeetL" at 5 and "LmeetB" at 1. This would result in the creation of five additional big bird clones and one additional little bird clone in addition to the base-line birth rate of one (net) additional clone.
'
There are three meters that calculate at the end of each round: (1) the total number of birds in the population (count birds); (2) the cumulative average proportion of Big birds (cumulative prop big); and (3) the cumulative average proportion of Little birds (cumulative prop little). The simulation also provides a graph of the relative proportion of the two breeds (prop big and little), as well as a graph of the number of each breed (num. big (red) and little (blue)). Each unit of time on the graphs represents one round of play. The reference lines are at 1/3 and 2/3. A breed or population that reaches the carrying capacity ceiling as well as a breed or population that dies out can be easily seen on the graphs.
These meters reflect deaths in tar pits and cloning in nesting sites; however, they are calculated prior to the impact of a population exceeding the carrying capacity limit; consequently the (count birds) and the (num. big (red)) and (num. little (blue)) may "bounce" above the carrying capacity limit.
'
SELF DIRECTED EXERCISE
The following questions allow users to develop a basic understanding of the replicator dynamic approach to evolutionary game theory.
`
The LEARNING OBJECTIVES for this exercise are:
(1) an understanding of the simulation's replicator dynamic mechanics through experimentation; (2) an understanding of the risk of extinction for a "too-small" population due to the random possibility of death, even if expected payoffs do not predict extinction; (3) practice in first determining asymptotic stability in a replicator dynamic model based on stability condition equations, then verifying that the simulation arrives at the same answer; and (4) an understanding of the equivalence between a stable, mixed population and the mixed Nash equilibrium for a two player, two strategy game.
`
BASELINE BIRTH AND DEATH RATES
1. First, run the simulation with the "_meet_" sliders all left at 0 and "beta" and "delta" left at 0.25 each. Theoretically, with birth and death rates equal, the population should neither grow nor shrink. Observe that the random nature of the simulation causes a "random walk" pattern where sometimes the population eventually dies out, and sometimes it grows to carrying capacity. With these "meet" settings, there is no difference between payoffs for big versus little birds.
2. Change the "beta" setting to 0.26. Make sure the "_meet_" sliders are all left at 0. With birth rate slightly higher than death rate, what is the observed outcome? Does this make sense?
'
'
3. Change the "delta" setting so that it is slightly above "beta". With birth rate slightly lower than death rate, what is the observed outcome? Does this make sense?
'
'
'
'
'
LOW POPULATION, RANDOMNESS, AND EXTINCTION
`
4. Set "beta" at 0.25 and "delta" at 0.24. Reduce the starting number of birds to ten. Run a number of simulations with different initial bird settings.
a. What seems to be the minimum number of starting birds to avoid random extinction?
'
'
'
b. What does this imply regarding the random chance of extermination for a small population of an endangered species?
'
'
'
`
ASYMPTOTIC STABILITY IN A REPLICATOR DYNAMIC MODEL
`
Equilibrium in the replicator dynamic model is slightly different than the Evolutionarily Stable Strategy concept developed in the Mayberry simulation. A theoretical replicator dynamic model assumes an arbitrarily large population. With that assumption, over time, unsuccessful mutants are driven towards extinction; however, unlike the ESS concept, mutants never actually completely die out (e.g. if there is only one chance in a billion a mutant will survive, one mutant should survive if the population is assumed to be one billion or larger). If mutants are driven towards extinction, the incumbent population is said to be "asymptotically" stable, roughly the same thing as saying the incumbents are ESS in this two-player model. In this simulation with limited population size, asymptotic stability is inferred from the actual elimination of unsuccessful mutants. In other words, if the mutants die out, the incumbent population is stable.
To begin to develop this stability idea, mutant Big birds are introduced to the incumbent Little bird population. Set "beta" at 0.25 and "delta" at 0.24. Set "initial birds" at 200. Big birds will be the invading mutants, so they need to be a "small" number, so set "proportion_big" at 0.3. Set all "meet" sliders at 0.
'
'
DEFINING STABILITY USING RELATIVE PAYOFFS
Whether or not a population will be stable against an invasion of mutants can be predicted by looking at the relative payoffs when the two breeds encounter each other. To make the stability condition more concise, a set of equations can be used. To that end, let:
'
s* = the incumbent, Little bird strategy.
s = the mutant, Big bird strategy.
P = the payoff to the first breed when it encounters another bird.
For example, P( s*, s) represents the payoff to an incumbent Little bird when it encounters a mutant Big bird on a green patch.
Conversely, P( s, s*) represents the payoff to a mutant Big bird when it encounters an incumbent Little bird on a green patch.
Whether or not a population is stable can then be predicted as follows:
An incumbent (s*) population is asymptotically stable if the following equations are true:
'
`````````P(s*,s*) > P(s,s*)`````````````````````````````````````````````(1)
`
``````````````````If P(s*,s*) = P(s, s*)``````````````````````````````````(2)
`
````````````````````````then P(s*, s) > P(s,s)
'
In other words, if the payoff to an incumbent playing against another incumbent is greater than the payoff of a mutant playing against an incumbent (equation 1), then the incumbent population will successfully resist an invasion of mutants, regardless of the payoffs to the breeds when they play against mutants. Conversely, if the payoff to an incumbent playing against another incumbent is less than the payoff of a mutant playing against an incumbent, then equation (1) is not true and the incumbent population is not stable because an invasion of mutants will not be successfully driven towards extinction.
However, if equation (1) is an equality, then equation (2) determines if the incumbent population is stable. Now, if the payoff to an incumbent playing against a mutant is greater than the payoff of a mutant playing against another mutant (equation 2), then the incumbent population will successfully resist an invasion of mutants. Conversely, if the payoff to an incumbent playing against a mutant is less-than-or-equal-to the payoff of a mutant playing against another mutant, then equation (2) is not true and the incumbent population is not stable because an invasion of mutants will not be successfully resisted.
The payoffs used in equations (1) and (2) are determined by the four "meet" sliders in the program as follows:
P(s,s) = BmeetB`````````P( s, s*) = BmeetL
P( s*, s) = LmeetB````` P( s*, s*) = LmeetL
5. Given the initial "meet" settings of all 0, does equation (1) indicate that a population of Little birds will be stable against an invasion of mutant Big birds?
'
'
'
6. If it is necessary to look to equation (2), does that equation indicate that a population of Little birds will be stable against an invasion of mutant Big birds?
'
'
'
7. Based on your answers to 6 and 7, what do you expect to happen when you allow a small number of mutant big birds to invade the little bird population? To check your answer, set "beta" at 0.26, "delta" at 0.25, the "proportion big" at 0.3, click "setup", then run the simulation. Repeat a few times to get a sense of what typically happens. Do the graphs and readings on the cumulative proportion meters make sense?
'
'
'
8. Change the meet slider payoffs so that Little birds is now stable
using the equation (1): P( s*, s*) > P( s, s*).
Identify the slider positions you use below:
P( s, s) = BmeetB =_______ ```````````P( s, s*) = BmeetL = _____
`
P( s*, s) = LmeetB =______ ```````````P( s*, s*) = LmeetL =______
`
9. Change the "meet" slider payoffs so that equation (1) is an equality; however, the meet sliders are set so that equation (2)
P( s*, s) > P( s, s) still keeps the Little bird population stable.
Identify the slider positions you use below:
P( s, s) = BmeetB =_________````````````P( s, s*) = BmeetL =___________
`
P( s*, s) = LmeetB =_________```````````P( s*, s*) = LmeetL =___________
`
IRRELEVANCE OF BIRTH AND DEATH RATE
Notice that the birth and death rate is not included in the stability condition equations. This implies that as long as the population enjoys an overall birth rate that is greater than the death rate, the actual settings of the birth and death rate DO NOT impact the stability calculations.
To verify this, use the settings from question 9 above and change both the "delta" and "beta" to something over 0.40, and then set them both to something less than 0.10, and look for any changes in the outcome compared to question 9. (There should be none, unless a high death rate wipes out a low starting population). Write in the settings you experiment with below:
10. High beta = _______, High delta = ___________
````` Low beta = ______, Low delta = ___________
HAWKS AND DOVES
A game of "hawks and doves" is often used to demonstrate how asymptotic stability in a replicator dynamic model can include more than one breed (strategy).
The hawks and doves game is modeled in this simulation as follows:
If there are exactly two birds on a green nesting site, that site has additional resources. The two birds compete for these additional resources which result in the production of additional clones. The number of these additional clones is determined by the "_meet_" sliders.
Big birds exhibit aggressive, "hawk-like" behavior. Little birds exhibit a more passive and cooperative, "dove-like" behavior. If a Little bird and a Big bird land on a green nesting site at the same time, the Big bird aggressively takes most of the resources and creates 6 additional Big bird clones of itself while the Little bird is only able to create 2 additional Little bird clones. (Set BmeetL = 6, LmeetB = 2) If a Little bird meets a Little bird, they peacefully and equally split up the additional payoff between each other; consequently they each create 4 additional clones of Little birds (Set LmeetL = 4). If a Big bird meets another Big bird, they are both aggressive and waste energy fighting each other; consequently, both Big birds receive a smaller payoff than pairs of Little birds receive, equal to 1 in this scenario (Set BmeetB = 1).
With these payoffs, a small number of aggressive Big birds enjoy a significant advantage which translates into an increase in the proportion of Big birds. Eventually, the increased number of Big birds results in a large number of Big birds competing with each other for a low payoff and the more cooperative Little birds gain an advantage and increase their proportion. To see how this works, run the simulation a few times with these settings. (Set "proportion_big" at 0.5. Set "beta" at 0.26 and "delta" at 0.25. Set "initial birds" at 200. Click "setup".)
`
`
11. After running the simulation with these settings, what proportions do the cumulative proportion monitors settle at?
cumulative prop big = _____________
cumulative prop little = ____________
12. Exploring the relationship between a mixed two-breed replicator dynamic stability and mixed Nash Equilibrium in a symmetric, two-player, simultaneous move game.
The above "meet" payoff settings can be converted to a normal form game theory matrix (bird species playing against itself using two strategies) as follows:
```````````````Big Bird``````````Little Bird
Big Bird`````````1,1````````````````6,2
Little Bird```````2,6````````````````4,4
Calculate the mixed Nash equilibrium given these payoffs.
Proportion of Big bird strategy = ___________________
13. How does this calculation compare to the cumulative proportion of Big birds that arises in the simulation?
14. Mixed stabilities are fairly sensitive to changes in payoffs.
Change ONE of the payoffs from question 11 so that the Big birds again die out.
Identify the slider positions you use below:
P( s, s) = BmeetB = _______ P( s, s*) = BmeetL =__________
`
P( s*, s) = LmeetB =_______ P( s*, s*) = LmeetL = __________
b. Identify the stability condition equation that predicts Little bird stability based on these payoffs.
'
'
15. Now change the payoffs so that the mutant Big birds drive the Little birds to extinction.
a. Identify the slider positions you use below:
BmeetB = ___________ BmeetL = ___________
`
LmeetB = ___________ LmeetL = ___________
17. Develop a different story for Big and Little birds cooperating and competing. In this story, the LITTLE birds need to be the majority, yet the stable population must include both Big and Little birds.
NOTE: To maintain a stable mixed rather than a pure population, the relative values of payoffs need to be: BmeetL> LmeetL> LmeetB> BmeetB.
Indicate the slider positions you use to create the stable, mixed, majority-little-bird population below:
BmeetB =____________ BmeetL = _____________
`
LmeetB = ___________ meetL = _____________
`
`
`
18. Write out a brief narrative story supporting the above payoffs (e.g. why does LmeetL result in such a large payoff that is nonetheless lower than the BmeetL payoff, etc.):
`
`
`
`
`
RELATED MODELS
"Evolutionary Game Theory_Mayberry" is a much simpler approach to evolutionary game theory that models the stability concept of Evolutionarily Stable Strategies (ESS).
'
CONTACT THE AUTHOR
Dr. Jeffrey E. Russell
Department of Economics
Ashland University,
Ashland, OH
jrussell@ashland.edu
August 2007
@#$#@#$#@
default
true
0
Polygon -7500403 true true 150 5 40 250 150 205 260 250
link
true
0
Line -7500403 true 150 0 150 300
link direction
true
0
Line -7500403 true 150 150 30 225
Line -7500403 true 150 150 270 225
ant
true
0
Polygon -7500403 true true 136 61 129 46 144 30 119 45 124 60 114 82 97 37 132 10 93 36 111 84 127 105 172 105 189 84 208 35 171 11 202 35 204 37 186 82 177 60 180 44 159 32 170 44 165 60
Polygon -7500403 true true 150 95 135 103 139 117 125 149 137 180 135 196 150 204 166 195 161 180 174 150 158 116 164 102
Polygon -7500403 true true 149 186 128 197 114 232 134 270 149 282 166 270 185 232 171 195 149 186
Polygon -7500403 true true 225 66 230 107 159 122 161 127 234 111 236 106
Polygon -7500403 true true 78 58 99 116 139 123 137 128 95 119
Polygon -7500403 true true 48 103 90 147 129 147 130 151 86 151
Polygon -7500403 true true 65 224 92 171 134 160 135 164 95 175
Polygon -7500403 true true 235 222 210 170 163 162 161 166 208 174
Polygon -7500403 true true 249 107 211 147 168 147 168 150 213 150
arrow
true
0
Polygon -7500403 true true 150 0 0 150 105 150 105 293 195 293 195 150 300 150
bee
true
0
Polygon -1184463 true false 151 152 137 77 105 67 89 67 66 74 48 85 36 100 24 116 14 134 0 151 15 167 22 182 40 206 58 220 82 226 105 226 134 222
Polygon -16777216 true false 151 150 149 128 149 114 155 98 178 80 197 80 217 81 233 95 242 117 246 141 247 151 245 177 234 195 218 207 206 211 184 211 161 204 151 189 148 171
Polygon -7500403 true true 246 151 241 119 240 96 250 81 261 78 275 87 282 103 277 115 287 121 299 150 286 180 277 189 283 197 281 210 270 222 256 222 243 212 242 192
Polygon -16777216 true false 115 70 129 74 128 223 114 224
Polygon -16777216 true false 89 67 74 71 74 224 89 225 89 67
Polygon -16777216 true false 43 91 31 106 31 195 45 211
Line -1 false 200 144 213 70
Line -1 false 213 70 213 45
Line -1 false 214 45 203 26
Line -1 false 204 26 185 22
Line -1 false 185 22 170 25
Line -1 false 169 26 159 37
Line -1 false 159 37 156 55
Line -1 false 157 55 199 143
Line -1 false 200 141 162 227
Line -1 false 162 227 163 241
Line -1 false 163 241 171 249
Line -1 false 171 249 190 254
Line -1 false 192 253 203 248
Line -1 false 205 249 218 235
Line -1 false 218 235 200 144
big_bird
true
0
Polygon -7500403 true true 2 6 2 39 270 298 297 298 299 271 187 160 279 75 276 22 100 67 31 0
bird2
false
0
Polygon -7500403 true true 2 4 33 4 298 270 298 298 272 298 155 184 117 289 61 295 61 105 0 43
boat1
false
0
Polygon -1 true false 63 162 90 207 223 207 290 162
Rectangle -6459832 true false 150 32 157 162
Polygon -13345367 true false 150 34 131 49 145 47 147 48 149 49
Polygon -7500403 true true 158 33 230 157 182 150 169 151 157 156
Polygon -7500403 true true 149 55 88 143 103 139 111 136 117 139 126 145 130 147 139 147 146 146 149 55
boat2
false
0
Polygon -1 true false 63 162 90 207 223 207 290 162
Rectangle -6459832 true false 150 32 157 162
Polygon -13345367 true false 150 34 131 49 145 47 147 48 149 49
Polygon -7500403 true true 157 54 175 79 174 96 185 102 178 112 194 124 196 131 190 139 192 146 211 151 216 154 157 154
Polygon -7500403 true true 150 74 146 91 139 99 143 114 141 123 137 126 131 129 132 139 142 136 126 142 119 147 148 147
boat3
false
0
Polygon -1 true false 63 162 90 207 223 207 290 162
Rectangle -6459832 true false 150 32 157 162
Polygon -13345367 true false 150 34 131 49 145 47 147 48 149 49
Polygon -7500403 true true 158 37 172 45 188 59 202 79 217 109 220 130 218 147 204 156 158 156 161 142 170 123 170 102 169 88 165 62
Polygon -7500403 true true 149 66 142 78 139 96 141 111 146 139 148 147 110 147 113 131 118 106 126 71
box
true
0
Polygon -7500403 true true 45 255 255 255 255 45 45 45
butterfly1
true
0
Polygon -16777216 true false 151 76 138 91 138 284 150 296 162 286 162 91
Polygon -7500403 true true 164 106 184 79 205 61 236 48 259 53 279 86 287 119 289 158 278 177 256 182 164 181
Polygon -7500403 true true 136 110 119 82 110 71 85 61 59 48 36 56 17 88 6 115 2 147 15 178 134 178
Polygon -7500403 true true 46 181 28 227 50 255 77 273 112 283 135 274 135 180
Polygon -7500403 true true 165 185 254 184 272 224 255 251 236 267 191 283 164 276
Line -7500403 true 167 47 159 82
Line -7500403 true 136 47 145 81
Circle -7500403 true true 165 45 8
Circle -7500403 true true 134 45 6
Circle -7500403 true true 133 44 7
Circle -7500403 true true 133 43 8
circle
false
0
Circle -7500403 true true 34 34 230
little_bird
true
0
Polygon -7500403 true true 135 165 90 270 120 300 180 300 210 270 165 165
Rectangle -7500403 true true 120 105 180 237
Polygon -7500403 true true 135 105 120 75 105 45 121 6 167 8 207 25 257 46 180 75 165 105
Circle -16777216 true false 128 21 42
Polygon -7500403 true true 163 116 194 92 212 86 230 86 250 90 265 98 279 111 290 126 296 143 298 158 298 166 296 183 286 204 272 219 259 227 235 240 241 223 250 207 251 192 245 180 232 168 216 162 200 162 186 166 175 173 171 180
Polygon -7500403 true true 137 116 106 92 88 86 70 86 50 90 35 98 21 111 10 126 4 143 2 158 2 166 4 183 14 204 28 219 41 227 65 240 59 223 50 207 49 192 55 180 68 168 84 162 100 162 114 166 125 173 129 180
person
false
0
Circle -7500403 true true 155 20 63
Rectangle -7500403 true true 158 79 217 164
Polygon -7500403 true true 158 81 110 129 131 143 158 109 165 110
Polygon -7500403 true true 216 83 267 123 248 143 215 107
Polygon -7500403 true true 167 163 145 234 183 234 183 163
Polygon -7500403 true true 195 163 195 233 227 233 206 159
spacecraft
true
0
Polygon -7500403 true true 150 0 180 135 255 255 225 240 150 180 75 240 45 255 120 135
thin-arrow
true
0
Polygon -7500403 true true 150 0 0 150 120 150 120 293 180 293 180 150 300 150
truck-down
false
0
Polygon -7500403 true true 225 30 225 270 120 270 105 210 60 180 45 30 105 60 105 30
Polygon -8630108 true false 195 75 195 120 240 120 240 75
Polygon -8630108 true false 195 225 195 180 240 180 240 225
truck-left
false
0
Polygon -7500403 true true 120 135 225 135 225 210 75 210 75 165 105 165
Polygon -8630108 true false 90 210 105 225 120 210
Polygon -8630108 true false 180 210 195 225 210 210
truck-right
false
0
Polygon -7500403 true true 180 135 75 135 75 210 225 210 225 165 195 165
Polygon -8630108 true false 210 210 195 225 180 210
Polygon -8630108 true false 120 210 105 225 90 210
turtle
true
0
Polygon -7500403 true true 138 75 162 75 165 105 225 105 225 142 195 135 195 187 225 195 225 225 195 217 195 202 105 202 105 217 75 225 75 195 105 187 105 135 75 142 75 105 135 105
wolf-left
false
3
Polygon -6459832 true true 117 97 91 74 66 74 60 85 36 85 38 92 44 97 62 97 81 117 84 134 92 147 109 152 136 144 174 144 174 103 143 103 134 97
Polygon -6459832 true true 87 80 79 55 76 79
Polygon -6459832 true true 81 75 70 58 73 82
Polygon -6459832 true true 99 131 76 152 76 163 96 182 104 182 109 173 102 167 99 173 87 159 104 140
Polygon -6459832 true true 107 138 107 186 98 190 99 196 112 196 115 190
Polygon -6459832 true true 116 140 114 189 105 137
Rectangle -6459832 true true 109 150 114 192
Rectangle -6459832 true true 111 143 116 191
Polygon -6459832 true true 168 106 184 98 205 98 218 115 218 137 186 164 196 176 195 194 178 195 178 183 188 183 169 164 173 144
Polygon -6459832 true true 207 140 200 163 206 175 207 192 193 189 192 177 198 176 185 150
Polygon -6459832 true true 214 134 203 168 192 148
Polygon -6459832 true true 204 151 203 176 193 148
Polygon -6459832 true true 207 103 221 98 236 101 243 115 243 128 256 142 239 143 233 133 225 115 214 114
wolf-right
false
3
Polygon -6459832 true true 170 127 200 93 231 93 237 103 262 103 261 113 253 119 231 119 215 143 213 160 208 173 189 187 169 190 154 190 126 180 106 171 72 171 73 126 122 126 144 123 159 123
Polygon -6459832 true true 201 99 214 69 215 99
Polygon -6459832 true true 207 98 223 71 220 101
Polygon -6459832 true true 184 172 189 234 203 238 203 246 187 247 180 239 171 180
Polygon -6459832 true true 197 174 204 220 218 224 219 234 201 232 195 225 179 179
Polygon -6459832 true true 78 167 95 187 95 208 79 220 92 234 98 235 100 249 81 246 76 241 61 212 65 195 52 170 45 150 44 128 55 121 69 121 81 135
Polygon -6459832 true true 48 143 58 141
Polygon -6459832 true true 46 136 68 137
Polygon -6459832 true true 45 129 35 142 37 159 53 192 47 210 62 238 80 237
Line -16777216 false 74 237 59 213
Line -16777216 false 59 213 59 212
Line -16777216 false 58 211 67 192
Polygon -6459832 true true 38 138 66 149
Polygon -6459832 true true 46 128 33 120 21 118 11 123 3 138 5 160 13 178 9 192 0 199 20 196 25 179 24 161 25 148 45 140
Polygon -6459832 true true 67 122 96 126 63 144
@#$#@#$#@
NetLogo 3.1.3
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@