31:T4b0,md`### What are you seeing here? This is notebook three in a short series I've been assembling about when and how cooperation shows up in nature. The [first](https://observablehq.com/d/68247923b0ebd148) notebook outlines a basic Prisoner's Dilemma model in action. The [second](https://observablehq.com/d/75217e32a9188153) notebook shows something called the Green Beard Effect: a mechanism that can boost cooperation in a population, so long as agents have a reliable marker with which to identify kin or former collaborators. In this model, I wanted to show what happens when we use an *unreliable* marker as a cue for cooperation – one that shows up frequently in complex human societies: a person's apparent evolutionary fitness as communicated by their wealth. I came up with this model while working as a researcher in the evolutionary biology department at Princeton, and benefited enormously in its development from the wise and patient guidance of the brilliant [Corina Tarnita](https://eeb.princeton.edu/people/corina-tarnita). I believe that its implications are broad-reaching and particularly relevant in understanding contemporary social phenomena such as the power of the media. `32:T57b,{ const context = DOM.context2d(width, height); const colWidth = width / agentCount; let maxVal = initFitness; while (true) { context.clearRect(0, 0, width, height); if (agentList.length > 0) { let topAgent = agentList[agentCount - 1]; maxVal = topAgent.fitness; for (let i = 0; i < agentCount; i++) { let x = i * colWidth; let h = (agentList[i].fitness * height) / maxVal; let y = height - h; context.beginPath(); if (agentList[i].strategy.rich == 0) { context.fillStyle = "black"; } else { context.fillStyle = "steelblue"; } context.rect(x, y, colWidth-1, h/3); context.fill(); context.beginPath(); if (agentList[i].strategy.equal == 0) { context.fillStyle = "black"; } else { context.fillStyle = "seagreen"; } context.rect(x, y + (h/3), colWidth-1, h/3); context.fill(); context.beginPath(); if (agentList[i].strategy.poor == 0) { context.fillStyle = "black"; } else { context.fillStyle = "firebrick"; } context.rect(x, y + (2*h/3), colWidth-1, h/3); context.fill(); } } context.canvas.onmousedown = event => { mutable paused = !paused; }; yield context.canvas; } }33:T85a,{ const context = DOM.context2d(width, height); const colors = [ 'black', 'firebrick', 'seagreen', 'goldenrod', 'steelblue', 'darkorchid', 'darkcyan', 'tan' ]; while (true) { context.clearRect(0, 0, width, height); if (history.length >= 1) { let segWidth = Math.floor(width / history.length); let startIndex = 0; let segments = history.length; if (history.length > width) { segWidth = 1; startIndex = history.length - width; segments = width; } let barGap = 1; if (segments > 1500) { barGap = 1000; } else if (segments > 150) { barGap = 100; } else if (segments > 15) { barGap = 10; } else { barGap = 1; } for (let i = 1; i < segments; i++) { let xStart = (i-1) * segWidth; let xEnd = i * segWidth; let iStart = startIndex + (i-1); let iEnd = iStart + 1; for (let s = 0; s < 8; s++) { let yStart = height - (history[iStart].value[s]) * height; let yEnd = height - (history[iEnd].value[s]) * height; context.beginPath(); context.moveTo(xStart, yStart); context.lineTo(xEnd, yEnd); context.strokeStyle = colors[s]; context.stroke(); } if (iEnd % barGap == 0) { let v = iEnd * speed; context.beginPath(); context.moveTo(xEnd, 0); context.lineTo(xEnd, height); context.strokeStyle = "gray"; context.stroke(); context.fillText(`${v}`, xEnd + 2, height-10); } } } for (let i = 0; i < 3; i++) { let f = (i+1) / 4; context.beginPath(); context.moveTo(0, (1-f) * height); context.lineTo(width, (1-f) * height); context.strokeStyle = "gray"; context.stroke(); context.fillText(`${f}`, 0, -2 + ((1-f) * height)); } context.canvas.onmousedown = event => { mutable paused = !paused; }; yield context.canvas; } }34:Ta38,md` ### Explanation In this game, each agent has three behaviors: how they play when they meet someone poorer than themselves, how they play with peers, and how they play against those who are richer. Corina and I were interested in this extension of Prisoner's Dilemma because people have used wealth cues to guide their behavior since civilization began. What we own determines what kinds of group-membership signals we can display, and that in turn determines how others see us. But a person's apparent success *isn't* a reliable guide for how they'll treat you. The aim of this model is to use the minimum amount of complexity necessary to capture the kinds of behaviors that might show up in a real human system. All the specific detais that make human beings complicated have been left out. Hopefully, what's left are the universal patterns we might expect to see repeating in *any* society, regardless of its social habits or politics. ### Things to look for The dynamics in this game are different from other Prisoner's Dilemma variants I've seen. For starters, having three behaviors per agent makes for a far more complex set of strategy interactions. But there's more at work here than just that. In this model, an agent's prior success determines how they're treated by others. Depending on the strategies at work in the population, this can give rise either to positive or negative feedback cycles. The most noticeable example of this is what I think of as the *Murdoch Effect*. In this scenario, a few agents with the strategy: *cooperate only with the rich* gain advantage at the start of the simulation when wealth levels are relatively even and nobody is wealthier than they are. This makes it safe for them to defect. Then, once those agents become successful, their strategy becomes contagious. Other agents end up taking on the same behaviors as those early winners despite the fact that it makes them poorer. The wealthiest agents get richer and their means of propagating their strategy ever easier. This is just like what happens when public messaging is controlled by a narrow elite. As soon as a single in-group has secured control of the means of communication in a society, their interests are best served by propagating the message 'cooperate only with us and trust no one else'. This pattern can be seen in active use today everywhere from the Chinese government to Fox News because it efficiently centralizes power and reduces risks for those in charge. I recommend playing with the settings to see if you can determine the settings under which the Murdoch Effect takes over. `35:T464,//This function gets called each time-step, and updates the state of the population. function update() { /* NOTE: When referencing simulation variables directly, we *always* use the keyword mutable, otherwise the sim won't evaluate as expected. */ if (mutable steps % speed == 0) { captureState(mutable agentList, mutable history, mutable steps); } mutable agentList.sort((a, b) => a.fitness - b.fitness); if (Math.random() < pRepeat) { //Agent pair doesn't update } else { // Select a pair of agents to interact const indexA = Math.floor(Math.random() * agentCount); let indexB = indexA; while (indexB == indexA) { indexB = Math.floor(Math.random() * agentCount); } mutable agentA = agentList[indexA]; mutable agentB = agentList[indexB]; } applyCosts(mutable agentA, mutable agentB); // Trigger recycling with some probability if (Math.random() < pChange) { if (changeType == 'Pairwise') { makePairwiseChange(mutable agentA, mutable agentB); } else { makeAnonymousChange(mutable agentA, mutable agentB); } } }36:T78e,function makeAnonymousChange(agentA, agentB) { /* The aim here is to have selection that's general and mixed for both strong and weak agents. I perform roulette selection both times. When selecting a weak agent, I measure maxFitness-fitnessA for each agent A instead of just fitnessA. */ // Sum fitness of population let totalFitness = 0; for (const agent of agentList) { totalFitness += agent.fitness; } // Make agent selection from fitness range const hiSelection = Math.random() * totalFitness; // Iterate through agents looking for selection let parent = null; let cumulFit = 0; for (const agent of agentList) { cumulFit += agent.fitness; if (hiSelection < cumulFit) { parent = agent; break; } } // Find agent with highest fitness let maxFit = 0; for (const agent of agentList) { maxFit = Math.max(maxFit, agent.fitness); } //Add one to the max so that the highest scoring agent still has a gap of one maxFit++; //Find the sum of the deltas from each fitness value to the current max const totalDelta = (maxFit * agentCount) - totalFitness; // Make agent selection from total delta range const loSelection = Math.random() * totalDelta; // Iterate through agents looking for selection let child = null; let cumulDelta = 0; for (const agent of agentList) { cumulDelta += (maxFit - agent.fitness); if (loSelection < cumulDelta) { child = agent; break; } } if (Math.random() < pMutation) { //There's a small chance in every round that an agent will pick a random strategy child.strategy = { rich: Math.floor(Math.random() * 2), equal: Math.floor(Math.random() * 2), poor: Math.floor(Math.random() * 2) } } else { // Replace the low scoring agent strategy with the high scoring strategy child.strategy = Object.assign({}, parent.strategy); } }37:[] 2f:{"title":"Prisoner's Dilemma with Wealth Cues","cells":[{"id":0,"value":"md`# Prisoner's Dilemma with Wealth Cues`","pinned":false,"hidden":false,"mode":"ojs"},{"id":400,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":389,"value":"md`### Agents ranked by fitness\nEach bar represents an agent, and their height represents their wealth or 'fitness'. (Taller bars means higher fitness.) \nA red mark on a bar indicates that this agent cooperates with those poorer than themselves. A green mark indicates that the agent cooperates with peers. A blue mark indicates that they cooperate with those wealthier than themselves. Black marks indicate agents with the 'defect' strategy (self-interest). \n(Click on the plot to start or pause the simulation.) \n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":166,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":394,"value":"md`### Strategy frequency over time\nThis plot shows the changes in the relative frequency of different strategies in the population. \n* Red = cooperate only with the poor\n* Yellow = cooperate with peers and the poor\n* Green = cooperate only with peers\n* Turquoise = cooperate with peers and the rich\n* Blue = cooperate only with the rich\n* Purple = cooperate only with the rich and poor\n* Tan = cooperate with everyone\n* Black = cooperate with no one\n\n(Click on the plot to start or pause the simulation.)`","pinned":false,"hidden":false,"mode":"ojs"},{"id":175,"value":"$33","pinned":false,"hidden":false,"mode":"ojs"},{"id":163,"value":"// viewof bReset = button({value: \"Reset\", description: \"Click here to return the simulation to its initial conditions\"})\nviewof bReset = md``","pinned":false,"hidden":false,"mode":"ojs"},{"id":108,"value":"md`#### pRepeat\nThe probability that two agents interacting will meet each other again in the next simulation step.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":83,"value":"viewof slideRepeat = html``","pinned":false,"hidden":false,"mode":"ojs"},{"id":71,"value":"pRepeat = slideRepeat / 100;","pinned":false,"hidden":false,"mode":"ojs"},{"id":110,"value":"md`#### pChange\nThe probability that an agent will change their strategy if they interact with another that has higher fitness.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":86,"value":"viewof slideChange = html``","pinned":false,"hidden":false,"mode":"ojs"},{"id":15,"value":"pChange = slideChange / 100;","pinned":false,"hidden":false,"mode":"ojs"},{"id":558,"value":"md`#### rSimilar\nHow close the wealth between two agents needs to be for them to consider each other similar. A high similarity score means that agents need to have nearly identical wealth. A low score makes agents treat each other as peers more of the time.\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":553,"value":"viewof slideSimilar = html``","pinned":false,"hidden":false,"mode":"ojs"},{"id":559,"value":"rSimilar = slideSimilar / 100;","pinned":false,"hidden":false,"mode":"ojs"},{"id":453,"value":"md`### Strategy change method\nWhether agents get new strategies from the partners they interact with, or the population at large.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":448,"value":"viewof changeType = html``","pinned":false,"hidden":false,"mode":"ojs"},{"id":404,"value":"$34","pinned":false,"hidden":false,"mode":"ojs"},{"id":120,"value":"md`### Simulation Functions`","pinned":false,"hidden":false,"mode":"ojs"},{"id":137,"value":"//This gets called at the start of the simulation. It sets up our initial conditions. \nfunction init() {\n /*\n NOTE:\n When referencing simulation variables directly, we *always* use the keyword mutable, \n otherwise the sim won't evaluate as expected.\n */\n \n mutable agentList = [];\n for (let i = 0; i < agentCount; i++) {\n let agent = {};\n agent.id = i;\n agent.fitness = initFitness;\n agent.strategy = {\n rich: Math.floor(Math.random() * 2),\n equal: Math.floor(Math.random() * 2),\n poor: Math.floor(Math.random() * 2)\n };\n mutable agentList.push(agent);\n }\n \n const indexA = Math.floor(Math.random() * agentCount);\n let indexB = indexA;\n while (indexB == indexA) {\n indexB = Math.floor(Math.random() * agentCount);\n } \n mutable agentA = agentList[indexA];\n mutable agentB = agentList[indexB];\n\n mutable steps = 0;\n mutable initialized = true;\n mutable history = [];\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":140,"value":"$35","pinned":true,"hidden":false,"mode":"ojs"},{"id":142,"value":"function applyCosts(agentA, agentB) {\n\n let aStrat = agentA.strategy.equal;\n let bStrat = agentB.strategy.equal;\n \n if (agentA.fitness * rSimilar > agentB.fitness) {\n aStrat = agentA.strategy.poor;\n bStrat = agentB.strategy.rich;\n } else if (agentB.fitness * rSimilar > agentA.fitness) {\n aStrat = agentA.strategy.rich;\n bStrat = agentB.strategy.poor;\n }\n \n // Allocate costs to agents based on strategy\n if (aStrat == bStrat) {\n if (aStrat == 0) {\n // Both players defect, no change in fitness\n } else {\n // Both players cooperate, both get b-c\n agentA.fitness += benefit - cost;\n agentB.fitness += benefit - cost;\n }\n } else {\n if (aStrat > bStrat && agentA.fitness > 0) {\n agentA.fitness += -cost;\n agentB.fitness += benefit;\n } else if (agentB.fitness > 0) {\n agentA.fitness += benefit;\n agentB.fitness += -cost;\n }\n }\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":147,"value":"// Occasional peerwise strategy contagion based on absolute fitness\nfunction makePairwiseChange(agentA, agentB) {\n \n let loAgent = agentA;\n let hiAgent = agentB;\n if (loAgent.fitness > hiAgent.fitness) {\n loAgent = agentB;\n hiAgent = agentA;\n }\n \n //There's a small chance in every round that an agent will pick a random strategy\n if (Math.random() < pMutation) {\n loAgent.strategy = {\n rich: Math.floor(Math.random() * 2),\n equal: Math.floor(Math.random() * 2),\n poor: Math.floor(Math.random() * 2)\n }\n } else {\n loAgent.strategy = Object.assign({}, hiAgent.strategy);\n } \n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":447,"value":"$36","pinned":true,"hidden":false,"mode":"ojs"},{"id":158,"value":"//Function to store the outcome of a round for display in the history timeline\nfunction captureState(agentList, history, steps) {\n \n let stratScores = new Array(8).fill(0);\n \n for (let agent of agentList) {\n let stratSlot = 0;\n stratSlot += agent.strategy.poor;\n stratSlot += 2 * agent.strategy.equal;\n stratSlot += 4 * agent.strategy.rich;\n stratScores[stratSlot]++; \n }\n \n for (let i = 0; i < 8; i++) {\n stratScores[i] /= agentCount;\n }\n \n let moment = {}\n moment.time = steps;\n moment.value = stratScores;\n history.push(moment);\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":29,"value":"md`### Simulation Constants`","pinned":true,"hidden":false,"mode":"ojs"},{"id":5,"value":"agentCount = 100","pinned":true,"hidden":false,"mode":"ojs"},{"id":9,"value":"initFitness = 100","pinned":true,"hidden":false,"mode":"ojs"},{"id":11,"value":"height = 200","pinned":true,"hidden":false,"mode":"ojs"},{"id":13,"value":"speed = 100","pinned":true,"hidden":false,"mode":"ojs"},{"id":19,"value":"cost = 2","pinned":true,"hidden":false,"mode":"ojs"},{"id":34,"value":"benefit = 5","pinned":true,"hidden":false,"mode":"ojs"},{"id":17,"value":"pMutation = 0.05","pinned":true,"hidden":false,"mode":"ojs"},{"id":61,"value":"md`### Simulation Variables`","pinned":true,"hidden":false,"mode":"ojs"},{"id":51,"value":"mutable agentList = [];","pinned":true,"hidden":false,"mode":"ojs"},{"id":63,"value":"mutable agentA = null;","pinned":true,"hidden":false,"mode":"ojs"},{"id":65,"value":"mutable agentB = null;","pinned":true,"hidden":false,"mode":"ojs"},{"id":125,"value":"md`### Framework Functions\nWhere possible, I've split away the functionality that relates to the simulation running framework from the code that runs the simulation itself. The hope here is that the same framework could be used for a large number of possible sims.`","pinned":false,"hidden":false,"mode":"ojs"},{"id":127,"value":"{\n while (true) {\n yield Promises.delay(tickRate, tickFunc());\n }\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":132,"value":"function tickFunc() { \n if (!initialized) {\n reset();\n }\n if (!paused) {\n update();\n mutable steps++;\n }\n return 0;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":135,"value":"function reset() {\n mutable steps = 0;\n mutable initialized = true;\n init();\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":180,"value":"{\n //Enables the reset button to work\n bReset;\n mutable initialized = false;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":22,"value":"md`### Framework Constants`","pinned":false,"hidden":false,"mode":"ojs"},{"id":30,"value":"tickRate = 1;","pinned":false,"hidden":false,"mode":"ojs"},{"id":39,"value":"md`### Framework Variables`","pinned":false,"hidden":false,"mode":"ojs"},{"id":42,"value":"mutable initialized = false;","pinned":false,"hidden":false,"mode":"ojs"},{"id":43,"value":"mutable steps = 0;","pinned":false,"hidden":false,"mode":"ojs"},{"id":46,"value":"mutable history = [];","pinned":false,"hidden":false,"mode":"ojs"},{"id":48,"value":"mutable paused = true;","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W37","stdlib":"1","titling":"auto"}