31:T77e,{ const context = DOM.context2d(width, height); 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; let yStart = height - (history[iStart].value) * height; let yEnd = height - (history[iEnd].value) * height; context.beginPath(); context.moveTo(xStart, yStart); context.lineTo(xEnd, yEnd); context.strokeStyle = "black"; 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; } }32:Ta0f,md` ### Explanation The Prisoner's Dilemma is a pattern that shows up all over the place in everything from international trade agreements to the origins of life itself, or even discussions of whose turn it is to buy the next round of beers. At some level, understanding this game and how it works provides a platform for understanding most of what we experience in life. If you'd like to learn more about it, [this](https://www.youtube.com/watch?v=t9Lo2fgxWHw) is a fun place to start. Or check out the [Wikipedia page](https://en.wikipedia.org/wiki/Prisoner%27s_dilemma) for more technical details. In this simulation, we start with a bunch of agents with the same amount of money and preprogrammed behaviors that make them cooperate (pay a small cost to help others) or defect (follow self-interest and pay no cost). These behaviors are chosen via a digital coin-flip. In a given time-step, two agents are picked at random to play a game. If an agent decides to cooperate, they pay a small price for doing so. If an agent's partner cooperates, they get a benefit larger than the price their partner paid to help out. Clearly, the best thing for any agent on their own to do is not pay the price and hope their partner cooperates. On the other hand, the best outcome for any *pair* of agents is for them to both cooperate because then they're collectively better off than for any other combination of actions. What makes cooperation happen, then, is how much of the time agents operate in persistent groups, compared to how much they operate in isolation. But there's a catch: agents have to have the opportunity to figure out that cooperation can come with benefits. So if cooperative agents don't change their strategy when confronted with self-interested defectors they'll lose everything before then can learn. In that case, the defectors will win and cooperation won't emerge. This means in order for cooperation to show up in nature or society, the conditions have to be just right. This is why choosing the anonymous change option above pretty much rules out cooperation dominating. ### Motivation I picked Observable for this project because I wanted it to be clear just how easy it is to build a simulation like this and I wanted to enable others to tinker with the code if they wanted. I'm also keen to share more and this very well-understood game struck me as a great starting point for explaining some new models I have in mind. I believe that simple simulations are a fantastic way to understand the world and test our intuitions about how things work. `33: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); } } }34:T70f,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 = Math.floor(Math.random() * 2); } else { // Replace the low scoring agent strategy with the high scoring strategy child.strategy = parent.strategy; } }35:[] 2f:{"title":"Iterated Prisoner's Dilemma","cells":[{"id":0,"value":"md`# Iterated Prisoner's Dilemma`","pinned":false,"hidden":false,"mode":"ojs"},{"id":400,"value":"md`### What are you seeing here?\nPrisoner's Dilemma is arguably the most famous game in all of Game Theory. Researchers in fields spanning from evolutionary biology to economics use it to understand how and when altruistic behavior can outcompete self-interest. To find out for yourself, pick some values on the sliders below and then click the bar chart to run the model. An explanation of the model and the science behind it can be found underneath the visualizations.\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":389,"value":"md`### Agents ranked by fitness\nEach bar represents an agent, and their height represents their 'fitness'. (Taller bars means higher fitness.) Black bars indicate agents with the 'defect' strategy (self-interest). Blue bars indicate agents who cooperate. \n(Click on the plot to start or pause the simulation.)`","pinned":false,"hidden":false,"mode":"ojs"},{"id":166,"value":"{\n const context = DOM.context2d(width, height);\n const colWidth = width / agentCount;\n let maxVal = initFitness;\n \n while (true) { \n \n context.clearRect(0, 0, width, height);\n if (agentList.length > 0) {\n \n let topAgent = agentList[agentCount - 1];\n maxVal = topAgent.fitness;\n \n for (let i = 0; i < agentCount; i++) {\n let x = i * colWidth;\n let h = (agentList[i].fitness * height) / maxVal;\n let y = height - h;\n\n context.beginPath();\n if (agentList[i].strategy == 0) {\n context.fillStyle = \"black\";\n } else {\n context.fillStyle = \"steelblue\";\n }\n context.rect(x, y, colWidth-1, h);\n context.fill();\n }\n }\n\n context.canvas.onmousedown = event => {\n mutable paused = !paused;\n };\n \n yield context.canvas;\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":394,"value":"md`### Defector fraction over time\nChanges in the fraction of agents in the population with the defector strategy. \n(Click on the plot to start or pause the simulation.)`","pinned":false,"hidden":false,"mode":"ojs"},{"id":175,"value":"$31","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``\n","pinned":false,"hidden":false,"mode":"ojs"},{"id":15,"value":"pChange = slideChange / 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":"$32","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 = Math.floor(Math.random() * 2);\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":"$33","pinned":true,"hidden":false,"mode":"ojs"},{"id":142,"value":"function applyCosts(agentA, agentB) {\n \n // Allocate costs to agents based on strategy\n if (agentA.strategy == agentB.strategy) {\n if (agentA.strategy == 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 (agentA.strategy > agentB.strategy && 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 = Math.floor(Math.random() * 2);\n } else {\n loAgent.strategy = hiAgent.strategy;\n }\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":447,"value":"$34","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 defectorCount = 0;\n for (let agent of agentList) {\n if (agent.strategy == 0) defectorCount++;\n }\n let defectFrac = defectorCount / agentCount;\n \n let moment = {}\n moment.time = steps;\n moment.value = defectFrac;\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":"$W35","stdlib":"1","titling":"auto"}