35:["$","title",null,{"children":"Correlation with Cooperation in the Prisoner's Dilemma | kmk8334 | Observable"}] 3d:T786,Intro = md` # Correlation with Cooperation in the Prisoner's Dilemma This visualization analyzes the British game show [Golden Balls](https://en.wikipedia.org/wiki/Golden_Balls), a real-world spin-off of the prisoner's dilemma. On the show, life-changing sums of money can be won or lost from a single decision: will contestants split their jackpot winnings with the other finalist, or will they try stealing all of the the whole jackpot for themselves? ## What is Golden Balls? Skipping the finer details of the rules, the contestants' objective is to make it to the finals with a large jackpot and choose to either split their winnings with the other contestant or try stealing the whole jackpot. Each player is dealt golden balls ranging from £3 to £75,000 (roughly 100,000 USD), with identical killer balls mixed in, which act as a 0.1x multiplier to the jackpot if they're picked in the final round. ### Rounds 1 and 2 The contestants must vote out one contestant — usually the player with the worst hand — sending them home with nothing. The remaining contestants' golden balls are then shuffled and redealt, with a few new golden balls mixed in. This process repeats once more until only two contestants remain. ### Final round In the finals, two contestants pick 5 of the 10 remaining balls randomly for the final jackpot. Next, the contestants prepare to choose whether they will split or steal the jackpot winnings. They are offered one conversation to discuss among each other why both of them should split. Finally, their decision is locked in, and they simultaneously reveal their choice. * If both contestants choose "Split," they both go home with half of the jackpot. * If one contestant chooses "Split" and the other chooses "Steal," the stealer goes home with the entire jackpot, and the splitter leaves with nothing. * If both contestants choose "Steal," they both leave the show empty-handed. `3e:T8bc,SplitOrStealPerContestant = md` ## What is the prisoner's dilemma? As a game developer myself, I find the [prisoner's dilemma](https://en.wikipedia.org/wiki/Prisoner%27s_dilemma) a fascinating concept of game theory. In this scenario, two prisoners are held in captivity, with no way of communicating with one another. The police have solid evidence of both prisoners committing a minor crime worth 1 year of jail time, but no evidence for the major crime the duo committed worth 3 years' time. To try gaining a confession for the crime, they offer the prisoners a deal: * If both prisoners remain silent, they will both serve 1 year each in prison for the minor crime. * If one prisoner confesses against their partner, their 1 year will be acquitted, and the prisoner who remained silent will serve 4 years for both crimes. * If both prisoners confess against one another, their minor crimes will be acquitted, but they will both serve 3 years for the major crime. ## Why not just always cooperate? Intuitively, both partners should work together and cooperate to serve the minimum sentence of 2 years total. Logically speaking, however, both partners should betray one another. This is because it is always in an individual's best interest to betray their partner. If their partner betrays them, confessing will mean the individual will only serve 3 years instead of 4 for both crimes. Even better, if their partner remains silent and they betray, they'll avoid going to jail altogether. This state is considered a [Nash equilibrium](https://en.wikipedia.org/wiki/Nash_equilibrium). This occurs when no individual player can benefit from changing their strategy while other players do not change strategies. The Nash equilibrium is often the worst outcome for all involved, but since no individual player benefits from altruism, all players suffer from the [tragedy of the commons](https://en.wikipedia.org/wiki/Tragedy_of_the_commons). ## So how often do contestants cooperate? A total of 298 out of 568 contestants chose to try splitting the winnings, or a little over half. This sounds harsh — and to an extent, it is — but it's important to remember that a single number doesn't always paint the full picture. `3f:T682,JackpotSize = md` ## Higher stakes lead to a higher level of distrust In situations where the stakes were £500 or less, contestants approached a 75% cooperation rate, far beyond the statistical average of 52%. Similarly, jackpots above £8,000 have a cooperation rate of around 45%, significantly below the average, with the outlier being the £32,001-to-£64,000 bracket. ## A theory for this correlation As the jackpot size increases, contestants have much more on the line to lose from being betrayed, or gain from being greedy. In addition to greed, many contestants who have stolen have stated they did it defensively; they would rather steal money from someone who splits than take the chance of splitting with someone who steals. In contrast, with lower stakes, contestants have less to gain from choosing steal, so their external motivations have a greater impact on their decision-making. A contestant may prefer not sacrificing their morality for pocket change, or perhaps they believe that the judgement of friends and family is not worth the money. ## What about the outliers? It is important to note that these are inidividual brackets, not a weighted average. The smallest bracket contains 22 samples, so the noise of randomness is bound to show up in these small brackets. As for the £501-to-£1,000 bracket being so low, I believe this may have to do with frustration on a botched jackpot. Many jackpot sizes end up being around £7,500, but drawing a killer ball as the last of 5 jackpot balls will reduce the winnings by 90%. Players will be upset by this outcome, and some may take their anger out on their opponent by stealing as revenge. `40:T683,Gender = md` ## Gender is not statistically significant by itself In this comparison, females split 53% of the time, while males split 51% of the time, compared to 52% as the statistical average. I am not a statistician, so I do not know what the margin of error would be for this dataset, but these values most likely do not deviate from the average enough to matter. This is comparable to flipping a coin 300 times and getting heads or tails 3 times more than the average of 150. ## Not all visualizations will provide meaningful results Sometimes, a subset of data will be completely meaningless for correlation, and that's okay! Knowing a property has no correlation is knowledge in itself. When it comes to analyzing data, especially of a binary nature, it is important to be mindful of random chance skewing the results. ## Gender *does* act as an indicator when combined with a comparison of age Bizarrely enough, the [research paper](https://www.semanticscholar.org/paper/b478d7c439c7c17c169ca27f91dbf82505792096) that this project is based on found that male and female have a significant difference when considering the contestants' age as well. Males started at a 33% cooperation rate below age 30, and rose all the way to over 75% by age 50 and above. In contrast, females started at a baseline of around 42% cooperation below age 30, increasing to a little over 60% from ages 30-40, and reducing back down to 40-to-45% afterwards. This is a very interesting discovery, but complex grouped bar charts are outside the scope of this project. For those who are interested, I strongly encourage looking through the insights that the paper offers as well. `41:T436,Education = md` ## Education has a slight impact on cooperation rates In the dataset, contestants' level of education was estimated by their self-reported job titles. A higher level of education was defined by a job that would likely require a bachelor's degree or higher for education. Contestants with a high level of education had a 55% cooperation rate, slightly above 51% for a low level of education. With a sample size of 194 contestants with high educational attainment and 374 contestants with low educational attainment, I believe this holds statistical significance, albeit minor. ## Students are less likely to cooperate As a student myself, I was disappointed to learn that students had a subpar cooperation rate of 49%. It's a striking difference between the 55% average for high education. This may be due to margin of error — only 49 students are in this sample, meaning this is only 3 "coin flips" below average. It makes sense though: at our age, an extra few thousand dollars would mean a lot to pay down student loans, which brings me to my next point. `42:Tf98,MotivesForTrustworthiness = md` ## Contestants' Final Discussion: Reasons Given to Split In the final conversation, contestants have a discussion before making their choice. Since lying is allowed throughout the entire game, contestants always**[*](https://www.youtube.com/watch?v=S0qjK3TWZE8)** say they will split, no matter what their real intent is. Since contestants will only win money if their opponent picks split, their trust must be won over. This chart indicates the likelihood for someone to split based on if they made at least one statement that matches the given statement type. This chart is the most important, but also has the most dense information. I'll do my best to unpack what it means. ## Defining Key Meanings **Explicit Unconditional** (EU) statements mean that the contestant explicitly told their opponent "I will split," "I will not steal," "There is no way I am going to pick the steal ball," etc. **Implicit Unconditional** (IU) statements means that the contestant implied they would split or not steal due to some underlying motivation. There are several different types recorded: * **IU Character** - implying a desire to split due to one's moral character (e.g. "I am not the kind of person who steals") * **IU Past Intent** - implying that the contestant always wanted to split (e.g. "I came here to play an honest game") * **IU Preference** - implying a personal preference to split (e.g. "I want to split with you") * **IU Money** - implying satisfaction with half of the jackpot (e.g. "£30,000 pounds is enough") * **IU Viewers** - implying fear of judgement from spectators if they picked steal (e.g. "Everyone who knows me would be disgusted") * **IU Plea for Trust** - implying that their opponent can trust them to choose split (e.g. "You can trust me") **Explicit Conditional** (EC) statements mean that the contestant directly stated they would split only if some if-clause conditional was met (e.g. "I will split if you split") **Implicit Conditional** (IC) statements mean that the contestant implied they would split only if some if-clause conditional was met (e.g. "I am willing to choose split if you choose split") **None said** means that the contestant never gave a statement assuring their opponent that they will split or not steal. ## Insights from the Visualization The type of motivation the contestant told their opponent for splitting has a strong indication to whether the contestant is telling the truth about stealing or trying to deceive their opponent. ### Contestants who stated fear of judgement are most likely to split The strongest indicator of cooperation is a contestant saying they fear judgement from spectators, family, friends, etc., with a 76% cooperation rate compared to the 52% average. These contestants most likely value social harmony, and would feel immoral if they chose greed over the well-being of others. ### Contestants who mentioned moral character are also likely to split Those who mentioned that stealing would compromise their character (e.g. "I am not the kind of person who steals," "My conscience will not allow me to steal," "I couldn't steal," etc.) had a 75% cooperation rate, not far behind the motivation of viewers. This implies that those who know they will steal often avoid referencing their own morality. ### Contestants who mentioned half of the jackpot is good enough were less likely to split Referencing the exact size of the jackpot (e.g. "I want half the jackpot," "£30,000 pounds is enough" with a jackpot of £60,000, etc.) resulted in a negative correlation of cooperation. Only 47.5% of these 141 contestants ended up splitting. ### Contestants who did not state their motivation to split were the least likely to cooperate Only 36% of contestants who gave no motive to split ended up cooperating. These contestants often pushed the conversation towards gaining reassurance from their opponent splitting to dodge the necessity to lie about their own choice. `43:T5b5,Conclusion = md` ## Conclusion In high stakes scenarios, there are multiple indicators that predict how likely someone is to cooperate. Higher stakes have an inverse correlation with cooperation; age has a positive correlation with cooperation; being betrayed has an inverse correlation with cooperation; and the kinds of motives an individual says — or doesn't say — have a strong correlation with the trustworthiness of claiming they will cooperate. It is important to remember that these are individuals who had never met before, and they only knew each other for 60 minutes leading up to a possibly life-altering decision. Since contestants never met one another before the game show, they had no former reputation of trust to go off. Also, this is not a pure representation of the prisoner's dilemma: since contestants may communicate before making their decision, it is a modified version. ## Thank you for reading my project! If you'd like to explore the prisoner's dilemma more, I'd recommend checking out [The Evolution of Trust](https://ncase.me/trust/), an interactive game that explores what trust means and how it is built. The concept of [Nash equilibrium](https://en.wikipedia.org/wiki/Nash_equilibrium) further explains why players have incentive to behave selfishly. Last but not least, the [research paper](https://www.semanticscholar.org/paper/b478d7c439c7c17c169ca27f91dbf82505792096) associated with this project is a good read too! `44:Td44,ClassWriteUp = md` ## For Class: Write-Up of Process #### Step 1: Find an Interesting Dataset For project 1, my class was tasked with finding a public dataset. With this data, we created a data visualization that presented data insights that would be difficult to spot with numerics alone. I wanted to learn how to tell whether a player would cooperate in the prisoner's dilemma, so I searched for data on the British game show Golden Balls. Sure enough, I found [a research paper](https://www.semanticscholar.org/paper/b478d7c439c7c17c169ca27f91dbf82505792096) using a detailed dataset of each episode's final contestants. #### Step 2: Clean the Dataset To sanitize the data of errors, I used OpenRefine, a power tool made by Google for making mass changes to fix erroneous datasets. Thankfully, this dataset had a rigorous standard of quality for its research paper. The only changes I needed were removing the commas from the Maximum amount and Prize pool columns, and renaming the column \`"Episode "\` to \`"Episode"\`. I then converted it to a CSV for easier access on Observable. Besides the few easy minor changes, the dataset was flawless, and I am thrilled with the level of detail it offers. #### Step 3: Plan the data visualizations My plan went through a few iterations on what I wanted to analyze, but I opted to create an API for generating a subset of data, setting up a config variable, and passing the two into a templated chart generator. #### Step 4: Format the CSV object to a JSON object Using a \`d3.csvParse(...)\` and a \`rowConverter(csvRow)\` function, I was able to format the CSV into a neatly organized JSON object. This process further sanitized the data by converting Integer \`0/1\` values to Boolean \`true/false\` values, and parsing integers/floats from strings of numbers. #### Step 5: Create data subset generators By creating a subset of data, I was able to pass in a list of \`{name, value}\` objects to render to the screen. This process involved counting how many times a subset of contestants split or stole, then reformatting the counts into a percentage of how often the event occurred. #### Step 6: Create the pie and bar charts using a subset Getting the first chart of each type working was the most difficult part of the project. After I had a functional prototype, making modifications was a matter of checking documentation and looking for other projects that implemented similar functionality. #### Step 7: Reuse the API to generate extra charts After I had one of each type of chart working, creating a brand new chart was a matter of minutes. Creating subset generators for new charts was simple since it only involved conditional counting and simple division. My original plan was to make about five charts, but after seeing how easy and fun making new charts was, I nearly doubled the scope to nine instead. The most expensive portion of development was creating the two initial charts; after those were working, producing more charts was cheap. #### Step 8: Tell the Story of Discoveries Once my charts were complete, I examined correlations of data, and theorize why the data may be the way it is. As a disclaimer, I am not a professional in statistical analysis. I am cautious to provide definite reasons for causation to correlations; my theories are merely my best guess. ## Scroll down to see the code that generates charts! `45:T1014,// Format each CSV row into a more suitable JSON object rowConverter = (row) => { let formattedRow = { // SE.EP format episode: row["Episode"], // Contestant's name name: row["Name"], // How many shows were already aired publicly before the contestant's game // transmissions: parseInt(row["Transmissions"]), // Age of the contestant, estimated if not explicitly stated // Estimates are the mean of 2-3 coders' guesses for how old the contestant is ageEstimate: parseFloat(row["Age est."]), // M for male, // F for female gender: row["Gender"], // true if the contestant is white, // false otherwise // isWhite: (row["Race white"] == 1), // true if the contestant lives in an urban area with >250000 population, // false otherwise // livesInCity: (row["City"] == 1), // true if the contestant lives in the Greater London Urban Area, // false otherwise // livesInUrban: (row["London Urban Area"] == 1), // H for high - based on self-reported job titles that indicate a college education requirement // L for low education: row["Education est."], // true if the contestant is an undergrad or postgrad student, // false otherwise isStudent: (row["Student"] == 1), // true if the other final contestant attempted to vote them off in an earlier rounds, // false if the other final contestant voted with them throughout both preceding rounds opponentAttemptedVotingOff: (row["Vote received opp."] == 1), // Optimal jackpot outcome from drawing 5 of the 10 final golden balls // maxJackpot: parseFloat(row["Maximum amount"]), // Final jackpot outcome after drawing 5 of the 10 final golden balls jackpot: parseFloat(row["Prize pool"]), // "Split" if the player chose to split, "Steal" if they chose to steal splitOrSteal: row["Decision"], // Number of times the contestant made explicit unconditional (EU) statements that // they will split (e.g. "I will split", "I will not steal", etc.) EUStatements: parseInt(row["EU"]), // Number of times the contestant made implicit unconditional (IU) statements that // they will split (not explicit, but a reference to character, past intentions, etc.) IUStatements: parseInt(row["IU"]), // Number of times the contestant made an IU that they will not steal due to // their character (e.g. "My conscience will not allow me to steal") IUCharacterStatements: parseInt(row["IU character"]), // Number of times the contestant made an IU statement about past intentions // of not wanting to steal (e.g. "I came here to split") IUPastIntentionStatements: parseInt(row["IU past intention"]), // Number of times the contestant made an IU statement that they have // a personal preference for not stealing (e.g. "I want to split with you") IUPreferenceStatements: parseInt(row["IU preference"]), // Number of times the contestant made an IU statement by expressing that // half of the jackpot is good enough (e.g. "30,000 pounds is enough") IUMoneyStatements: parseInt(row["IU money"]), // Number of times the contestant makes an IU statement about not wanting to steal // due to judgement of the viewers (e.g. "Everyone who knows me would be disgusted") IUViewers: parseInt(row["IU viewers"]), // Number of times the contestant made an IU statement regarding a plea of trust (e.g. "You can trust me") IUPleaForTrust: parseInt(row["IU plea for trust"]), // Number of times the contestant made an explicit conditional statement on splitting // (e.g. "I will split if you split") ECStatements: parseInt(row["EC"]), // Number of times the contestant made an implicit conditional statement on splitting // (e.g. "I would like us to split") ICStatements: parseInt(row["IC"]), // true if the contestant revealed before the show that their choice depends on their opponent, // false if their choice is unconditional unconditionalSplitOrSteal: (row["Final depends O"] == 1), }; return formattedRow; }46:Tf47,// Generate a templated pie chart with the given subset of data and config params function makePieChart(subset, config) { // Unpack config variables and calculate the width/height constants const margins = config.margins; const innerRadius = config.dimensions.innerRadius; const outerRadius = config.dimensions.outerRadius; const width = (outerRadius * 2) + margins.left + margins.right; const height = (outerRadius * 2) + margins.top + margins.bottom; // Create the SVG element for the chart const svg = d3.create('svg') .attr('width', width) .attr('height', height); // Create a D3 pie layout that converts the dataset into one appropriate for pie charts const pie = d3.pie() .padAngle(margins.between) .value(d => d.value) .sort(null); // Avoid sorting the pie chart by largest size // Create a D3 arc generator used for drawing arcs based on the start/stop angles const arc = d3.arc() .innerRadius(innerRadius) .outerRadius(outerRadius); // Get the total count of events for the full pie chart (for calculating percentages) let totalCount = subset.reduce((acc, slice) => acc + slice.value, 0); // Get a reference to the color scale from the config variable const cScale = config.colorScale; // Show the data subset as a pie chart table in the devtools console // console.table(pie(subset)); // Create a element for each element of data const arcs = svg .selectAll('g.arc') .data(pie(subset)) .join('g') .classed('arc', true) .attr('transform', `translate(${outerRadius + margins.left}, ${outerRadius + margins.top})`); // Append an SVG path to each g element for the pie wedge arcs.append('path') .attr('fill', (d, i) => cScale(i)) .attr('d', arc) .append('title') // Alt-text for the pie slice .text(d => d.data.name); // Append labels to each pie wedge arcs.append('text') .attr('transform', d => `translate(${arc.centroid(d)})`) .attr('text-anchor', 'middle') .text(d => config.showPercentages ? parseFloat(d.value / totalCount * 100).toFixed(1)+"%" // Show as ##.#% : d.value // Show count of total event instances ) .style('fill', config.labelColor); // Break the chart into multiple lines for word wrapping let titleArray = config.chartTitle.split('\n'); // Create a text container at the center of the chart const title = svg.append('text') // Move the start of the container 8px up for each 16px line .attr('transform', `translate(${outerRadius + margins.left}, ${outerRadius + margins.top - (8 * titleArray.length)})`) .attr('text-anchor', 'middle') .attr('alignment-baseline', 'middle') .style('font-size', '16pt'); // Write each line into the title container for(let i = 0; i < titleArray.length; i++) { title.append('tspan') .text(titleArray[i]) .attr('x', 0) // Don't give extra vertical space to the first line .attr('dy', i == 0 ? '0em' : '1.2em'); } // LEGEND - built using Susie Lu's d3.svg.legend package const pieData = pie(subset); // Create a legend using the name of the category and its associated indexed color const legendScale = d3.scaleOrdinal() .domain(pieData.map(d => d.data.name)) .range(config.colorScale.range()); // see https://github.com/d3/d3-shape#symbols for information about d3 symbol shapes var legendOrdinal = d3Legend.legendColor() .shape('path', d3.symbol().type(d3.symbolSquare).size(60)()) .shapePadding(20) .orient('vertical') .scale(legendScale); // Append the legend to the chart svg.append('g') .attr('transform', `translate(${(outerRadius * 2) + margins.left - config.dimensions.legendPaddingX},${config.dimensions.legendPaddingY})`) .call(legendOrdinal); // Return the chart's SVG element so the caller can display the chart return svg.node(); }47:Tf71,// Generate a templated bar chart with the given subset of data and config params function makeBarChart(subset, config) { // Unpack the config JSON object for easier access in code let width = config.dimensions.width; let height = config.dimensions.height; let margins = config.margins; const svg = d3.create('svg') .attr('width', width) .attr('height', height); // colorScale is predefined in config.colorScale so // different bar charts can use different types of scales const cScale = config.colorScale; // create a scale for y-axis: use linear for the sleep data variable const yScale = d3.scaleLinear() .domain([0, 1]) .range([height - margins.bottom, margins.top]); // create a scale for x-axis: use time for the date data variable set the end // to be the day after the last date, so that the far right end of the scale // is going to allow the last day within the data set to show within the range const [dateMin, dateMax] = d3.extent(subset, d => d.value); const xScale = d3.scaleBand() .domain(d3.range(subset.length)) .range([margins.left, width - margins.right]); // Get a reference to the constant width of the bars const barWidth = (width - margins.left - margins.right) / subset.length - margins.between; // Generate a Y-axis based on the domain and range of yScale const yAxis = d3.axisLeft(yScale) .ticks(10) .tickFormat(d3.format(".0%")); // create our x-axis and customize look with .ticks() and // .tickFormat() const xAxis = d3.axisBottom(xScale) .ticks(subset.length) .tickFormat((d) => subset[d].name); // Append an element to the svg for the x-axis const xAxisGroup = svg.append('g') .attr('transform', `translate(0, ${height - margins.bottom})`) .call(xAxis); // Append an element to the svg for the y-axis const yAxisGroup = svg.append('g') .attr('transform', `translate(${margins.left}, 0)`) .call(yAxis) // For all axis ticks besides the bottom, // make it a dashed tick that spans the width of the graph .call(g => g.selectAll('.tick:not(:first-of-type) line') .attr('stroke-opacity', 0.5) .attr('stroke-dasharray', '2,2') .attr('x1', -6) .attr('x2', width - margins.right - margins.left)); // Append a title to the top-center of the chart svg.append("text") .text(config.axisLabels.title) .attr("x", margins.left + ((width - margins.left - margins.right) / 2)) .attr("y", 25) .attr("text-anchor", "middle") .style('font-family', 'sans-serif') .style("font-size", "20px") .style('fill', 'black'); // Append an x-axis label centered underneath the bottom axis xAxisGroup.append('text') .attr('class', 'axis-label') .text(config.axisLabels.x) .attr('x', margins.left + (width - margins.left - margins.right) / 2) .attr('y', 35) // Relative to the x axis position .attr('fill', 'black') .style('text-anchor', 'middle') .style('font-size', '14px'); // Append a y-axis label centered to the left of the left axis yAxisGroup.append('text') .attr('class', 'axis-label') .text(config.axisLabels.y) .attr('transform', 'rotate(-90)') .attr('x', -(margins.top + (height - margins.top - margins.bottom) / 2)) .attr('y', -38) // Relative to the y axis .attr('fill', 'black') .style('text-anchor', 'middle') .style('font-size', '14px'); // Draw the bars onto the chart svg.selectAll('.bars') .data(subset, d => d.value) .join('rect') .classed('bars', true) .attr('x', (d, i) => xScale(i) + margins.between / 2) .attr('height', d => height - margins.bottom - yScale(d.value)) .attr('width', barWidth) .attr('y', d => yScale(d.value)) .style('fill', (d, i) => cScale(d.value)) // Return the chart's SVG element so the caller can display the chart return svg.node(); }48:T4ae,// Generate a subset of data for the split/steal distribution function generateSubset_SplitOrSteals(dataset) { // Create data structure framework let subset = { perContestant: [ {name: "Splits", value: 0}, {name: "Steals", value: 0}, ], perEpisode: [ {name: "Both split", value: 0}, {name: "One splits, one steals", value: 0}, {name: "Both steal", value: 0}, ], }; // Loop through each episode (2 rows each, one for each contestant) for(let i = 0; i < dataset.length; i+=2) { if(dataset[i].splitOrSteal == "Split" && dataset[i+1].splitOrSteal == "Split") { // If both contestants from the 2 rows for an episode split subset.perEpisode[0].value++; subset.perContestant[0].value += 2; } else if(dataset[i].splitOrSteal == "Steal" && dataset[i+1].splitOrSteal == "Steal") { // If both contestants from the 2 rows steal subset.perEpisode[2].value++; subset.perContestant[1].value += 2; } else { // One of the contestants split, the other stole subset.perEpisode[1].value++; subset.perContestant[0].value++; subset.perContestant[1].value++; } } return subset; }49:Ta63,// Generate a subset of data for how often contestants split compared to the jackpot size function generateSubset_SplitPercentageVsJackpot(dataset) { // Create data structure framework let subset = { counts: [ {name: "0 - 250", outcome: {splits: 0, steals: 0}}, {name: "251 - 500", outcome: {splits: 0, steals: 0}}, {name: "501 - 1k", outcome: {splits: 0, steals: 0}}, {name: "1k - 2k", outcome: {splits: 0, steals: 0}}, {name: "2k - 4k", outcome: {splits: 0, steals: 0}}, {name: "4k - 8k", outcome: {splits: 0, steals: 0}}, {name: "8k - 16k", outcome: {splits: 0, steals: 0}}, {name: "16k - 32k", outcome: {splits: 0, steals: 0}}, {name: "32k - 64k", outcome: {splits: 0, steals: 0}}, {name: "64k - 128k", outcome: {splits: 0, steals: 0}}, ], percentages: [ {name: "0 - 250", value: 0}, {name: "251 - 500", value: 0}, {name: "501 - 1k", value: 0}, {name: "1k - 2k", value: 0}, {name: "2k - 4k", value: 0}, {name: "4k - 8k", value: 0}, {name: "8k - 16k", value: 0}, {name: "16k - 32k", value: 0}, {name: "32k - 64k", value: 0}, {name: "64k - 128k", value: 0}, ], }; // Categorize each contestant's decision into a jackpot size grouping for(let i = 0; i < dataset.length; i++) { // Contestant's jackpot size let jackpot = dataset[i].jackpot; // Bracket of prize winnings: // 0: 0.00 - 250.00 // 1: 250.01 - 500.00 // 2: 500.01 - 1000.00 // 3: 1000.01 - 2000.00 // 4: 2000.01 - 4000.00 // 5: 4000.01 - 8000.00 // 6: 8000.01 - 16000.00 // 7: 16000.01 - 32000.00 // 8: 32000.01 - 64000.00 // 9: 64000.01 - 128000.00 let bracketSize = 250; for(let j = 0; j < subset.counts.length; j++) { if(jackpot <= bracketSize) { // Determine which choice the contestant made // and use it as a field recerence to counts[i].outcome let choice = dataset[i].splitOrSteal == 'Split' ? 'splits' : 'steals'; // j indexes to the proper bracket size subset.counts[j].outcome[choice]++; // Move on to the next contestant break; } else { // Double bracketSize to increment to the next jackpot bracket bracketSize *= 2; } } } // Process the counts into percentages for(let i = 0; i < subset.counts.length; i++) { let totalOutcomes = (subset.counts[i].outcome.splits + subset.counts[i].outcome.steals); subset.percentages[i].value = subset.counts[i].outcome.splits / totalOutcomes; } // return the data structure return subset; }4a:T515,// Create a subset of data of how often males/females split/steal function generateSubset_MaleVsFemale(dataset) { // Create data structure framework let subset = [ {name: "Male - Split", value: 0}, {name: "Male - Steal", value: 0}, {name: "Female - Split", value: 0}, {name: "Female - Steal", value: 0}, ]; let males = 0; let females = 0; // Loop through each contestant for(let i = 0; i < dataset.length; i++) { if(dataset[i].gender == 'M') { // Male contestant males++; if(dataset[i].splitOrSteal == "Split") { // The male contestant picked split subset[0].value++; } else { // The male contestant picked steal subset[1].value++; } } else { // Female contestant females++; if(dataset[i].splitOrSteal == "Split") { // The female contestant picked split subset[2].value++; } else { // The female contestant picked steal subset[3].value++; } } } // Divide the counts by the total number of male/female participants // to convert from counts to percentages subset[0].value /= males; subset[1].value /= males; subset[2].value /= females; subset[3].value /= females; // Return the data structure return subset; }4b:T5f3,// Create a subset of data on how contestants chose compared to their education level function generateSubset_Education(dataset) { // Create data structure framework let subset = { counts: [ {name: "Low Education", outcome: {splits: 0, steals: 0}}, {name: "High Education", outcome: {splits: 0, steals: 0}}, {name: "Student", outcome: {splits: 0, steals: 0}}, ], percentages: [ {name: "Low Education", value: 0}, {name: "High Education", value: 0}, {name: "Student", value: 0}, ], }; // Loop through each contestant for(let i = 0; i < dataset.length; i++) { // Determine which choice the contestant made // and use it as a field recerence to counts[i].outcome let choice = dataset[i].splitOrSteal == 'Split' ? 'splits' : 'steals'; // Determine level of education if(dataset[i].education == 'L') { // Low education subset.counts[0].outcome[choice]++; } else { // High education subset.counts[1].outcome[choice]++; } // Is the contestant an active student pursuing higher education? if(dataset[i].isStudent) { subset.counts[2].outcome[choice]++; } } // Process the counts into percentages for(let i = 0; i < subset.counts.length; i++) { let totalOutcomes = (subset.counts[i].outcome.splits + subset.counts[i].outcome.steals); subset.percentages[i].value = subset.counts[i].outcome.splits / totalOutcomes; } // Return the data structure return subset; }4c:Ta12,// Create a subset of data on how contestants chose compared to their estimated age function generateSubset_Age(dataset) { // Create data structure framework let subset = { counts: [ {name: "<25 years", outcome: {splits: 0, steals: 0}}, {name: "25-29 years", outcome: {splits: 0, steals: 0}}, {name: "30-34 years", outcome: {splits: 0, steals: 0}}, {name: "35-39 years", outcome: {splits: 0, steals: 0}}, {name: "40-44 years", outcome: {splits: 0, steals: 0}}, {name: "45-49 years", outcome: {splits: 0, steals: 0}}, {name: "50-54 years", outcome: {splits: 0, steals: 0}}, {name: "55+ years", outcome: {splits: 0, steals: 0}}, ], percentages: [ {name: "<25 years", value: 0}, {name: "25-29 years", value: 0}, {name: "30-34 years", value: 0}, {name: "35-39 years", value: 0}, {name: "40-44 years", value: 0}, {name: "45-49 years", value: 0}, {name: "50-54 years", value: 0}, {name: "55+ years", value: 0}, ], }; // Loop through each contestant let bracketAgeIncrement = 5; // Width of age brackets for(let i = 0; i < dataset.length; i++) { let ageCutoff = 25; // Upper limit of the age bracket, exclusive let bracketFound = false; // Boolean check for the final age bracket, which is >5 years (55+) // Determine which choice the contestant made // and use it as a field recerence to counts[i].outcome let choice = dataset[i].splitOrSteal == 'Split' ? 'splits' : 'steals'; // Check for each age bracket <25, <30, <35, etc. up to <55 (but NOT <60, since it will be 55+) for(let j = 0; j < subset.counts.length - 1; j++) { if(dataset[i].ageEstimate < ageCutoff) { // j is indexed to the correct age bracket subset.counts[j].outcome[choice]++; // Escape the for-loop to prevent unnecessary extra checks bracketFound = true; break; } else { // Check the next age bracket ageCutoff += bracketAgeIncrement; } } // Check the final age bracket if(!bracketFound) { // The final age bracket is the correct age bracket subset.counts[subset.counts.length - 1].outcome[choice]++; } } // Process the counts into percentages for(let i = 0; i < subset.counts.length; i++) { let totalOutcomes = (subset.counts[i].outcome.splits + subset.counts[i].outcome.steals); subset.percentages[i].value = subset.counts[i].outcome.splits / totalOutcomes; } // Return the data structure return subset; }4d:Te91,// Create a subset of data based on what statements the contestant made in the final conversation before choosing function generateSubset_ConversationStatements(dataset) { // Create data structure framework let subset = { counts: [ {name: "EU", outcome: {splits: 0, steals: 0}}, {name: "IU Character", outcome: {splits: 0, steals: 0}}, {name: "IU Past Intent", outcome: {splits: 0, steals: 0}}, {name: "IU Preference", outcome: {splits: 0, steals: 0}}, {name: "IU Money", outcome: {splits: 0, steals: 0}}, {name: "IU Viewers", outcome: {splits: 0, steals: 0}}, {name: "IU Plea for Trust", outcome: {splits: 0, steals: 0}}, {name: "EC", outcome: {splits: 0, steals: 0}}, {name: "IC", outcome: {splits: 0, steals: 0}}, {name: "None Said", outcome: {splits: 0, steals: 0}}, ], percentages: [ {name: "EU", value: 0}, {name: "IU Character", value: 0}, {name: "IU Past Intent", value: 0}, {name: "IU Preference", value: 0}, {name: "IU Money", value: 0}, {name: "IU Viewers", value: 0}, {name: "IU Plea for Trust", value: 0}, {name: "EC", value: 0}, {name: "IC", value: 0}, {name: "None Said", value: 0}, ], }; // Loop through each contestant for(let i = 0; i < dataset.length; i++) { // Determine which choice the contestant made // and use it as a field recerence to counts[i].outcome let choice = dataset[i].splitOrSteal == 'Split' ? 'splits' : 'steals'; // If a contestant makes a type of statement at LEAST once, add them to the respective category // Player explicitly states they would unconditionally split or never steal if(dataset[i].EUStatements > 0) subset.counts[0].outcome[choice]++; // Player implies they would never steal since it goes against their own character if(dataset[i].IUCharacterStatements > 0) subset.counts[1].outcome[choice]++; // Player implies they had a past intention to unconditionally split or avoid stealing if(dataset[i].IUPastIntentionStatements > 0) subset.counts[2].outcome[choice]++; // Player implies they have a personal preference for unconditionally choosing split if(dataset[i].IUPreferenceStatements > 0) subset.counts[3].outcome[choice]++; // Player implies they will unconditionally split since they are satisfied with half the jackpot if(dataset[i].IUMoneyStatements > 0) subset.counts[4].outcome[choice]++; // Player implies they would unconditionally split due to judgement of the audience, viewers, friends, family, etc. if(dataset[i].IUViewers > 0) subset.counts[5].outcome[choice]++; // Player implies they could be trusted to unconditionally split if(dataset[i].IUPleaForTrust > 0) subset.counts[6].outcome[choice]++; // Player explicitly states they would split only on a given condition if(dataset[i].ECStatements > 0) subset.counts[7].outcome[choice]++; // Player implicitly states they would split only on a given condition if(dataset[i].ICStatements > 0) subset.counts[8].outcome[choice]++; // Player made no explicit or implicit statement that they would split/would not steal if(dataset[i].EUStatements == 0 && dataset[i].IUStatements == 0) subset.counts[9].outcome[choice]++; } // Process the counts into percentages for(let i = 0; i < subset.counts.length; i++) { let totalOutcomes = (subset.counts[i].outcome.splits + subset.counts[i].outcome.steals); subset.percentages[i].value = subset.counts[i].outcome.splits / totalOutcomes; } // Return the data structure return subset; }4e:T585,// Create a subset of data based on whether the player revealed their mind was already made // on their decision before the show started, or if their opponent would affect their choice function generateSubset_PredeterminedChoice(dataset) { // Create data structure framework let subset = [ {name: "Always split", value: 0}, {name: "Uncertain - split", value: 0}, {name: "Uncertain - steal", value: 0}, {name: "Always steal", value: 0}, ]; // Loop through each contestant for(let i = 0; i < dataset.length; i++) { if(dataset[i].unconditionalSplitOrSteal) { // The contestant already made their choice on whether they'd split or steal // before meeting their opponent, if(dataset[i].splitOrSteal == "Split") { // The contestant was planning on splitting no matter what subset[0].value++; } else { // The contestant was planning on stealing no matter what subset[3].value++; } } else { // The contestant waited to see whether they could trust their opponent to split if(dataset[i].splitOrSteal == "Split") { // The contestant decided it was worth splitting with their opponent subset[1].value++; } else { // The contestant decided it was not worth splitting with their opponent subset[2].value++; } } } // Return the data structure return subset; }4f:T68d,// Create a subset of data of how contestants voted if their opponent tried voting them out in an earlier round function generateSubset_OppoentAttemptedVotingOff(dataset) { // Create data structure framework let subset = [ {name: "No vote against - Split", value: 0}, {name: "No vote against - Steal", value: 0}, {name: "Voted against - Split", value: 0}, {name: "Voted against - Steal", value: 0}, ]; // Sum of splits and steals per category, stored so both subset values can use it for division let votesNotAgainst = 0; let votesAgainst = 0; // Loop through each contestant for(let i = 0; i < dataset.length; i++) { if(dataset[i].opponentAttemptedVotingOff) { // Other final contestant tried voting this contestant out in a previous round votesAgainst++; if(dataset[i].splitOrSteal == "Split") { // The contestant voted against opted to steal subset[2].value++; } else { // The contestant voted against opted to steal subset[3].value++; } } else { // The contestant's opponent never tried voting them out votesNotAgainst++; if(dataset[i].splitOrSteal == "Split") { // The contestant opted to split subset[0].value++; } else { // The contestant opted to steal subset[1].value++; } } } // Divide the counts by the total number of male/female participants // to convert from counts to percentages subset[0].value /= votesNotAgainst; subset[1].value /= votesNotAgainst; subset[2].value /= votesAgainst; subset[3].value /= votesAgainst; // Return the data structure return subset; }50:[{"id":"b53f1d0d7fd56f778ed6a3165f6cf6bea7893120b154c76aa748f690d309ea48ed1b4387a22956aca05c9943da54ed661ae5f1870d7f67f88303033933606aeb","href":"https://static.observableusercontent.com/files/b53f1d0d7fd56f778ed6a3165f6cf6bea7893120b154c76aa748f690d309ea48ed1b4387a22956aca05c9943da54ed661ae5f1870d7f67f88303033933606aeb","name":"dataset-malleable-lies.csv","type":"text/csv","lastModified":1616823714471.734,"size":42035}] 39:{"id":"7beae62ac57c9009","slug":"correlation-with-cooperation-in-the-prisoners-dilemma","title":"Correlation with Cooperation in the Prisoner's Dilemma","thumbnail":"2abbc9ef63c9ad5d7a60ec0c885ac5f9348914f77f0d9f649f7e3418a4664fe4","access_level":"public","create_time":"$D2021-03-22T13:15:02.687Z","update_time":"$D2021-04-06T05:17:09.448Z","view_time":null,"first_public_time":"$D2021-04-06T19:58:13.455Z","has_unpublished_edits":null,"fork":true,"stars":0,"starred":false,"owner":{"type":"team","id":"871e897e4e761887","login":"kmk8334","name":"","avatar_url":"https://avatars-next.observableusercontent.com/6a517547a73368236703b6a237d443bb1086cba4f16823c1ef46db0d92d4e1ad","tier":"starter_2024","bio":"","followed_by_you":false,"follows_you":false},"version":1793,"publish_version":1793,"role":null,"authored":false,"authors":[{"type":"individual","id":"a3540a18c2b4f3c6","login":"kmk8334","name":"","avatar_url":"https://avatars-next.observableusercontent.com/6a517547a73368236703b6a237d443bb1086cba4f16823c1ef46db0d92d4e1ad","tier":null,"bio":"","followed_by_you":false,"follows_you":false}],"members":[{"type":"individual","id":"a3540a18c2b4f3c6","login":"kmk8334","name":"","avatar_url":"https://avatars-next.observableusercontent.com/6a517547a73368236703b6a237d443bb1086cba4f16823c1ef46db0d92d4e1ad","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":1,"collection":null,"type":"notebook","body":{"titling":"auto","title":"Correlation with Cooperation in the Prisoner's Dilemma","cells":[{"id":1128,"value":"$3d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":99,"value":"Chart_1 = {\n // Get the applicable subset of data\n let subset = generateSubset_SplitOrSteals(dataset);\n \n // Create a convig variable with various chart properties\n let config = {\n // width x height of the chart canvas\n dimensions: {\n innerRadius: 80,\n outerRadius: 150,\n legendPaddingX: 40,\n legendPaddingY: 20,\n },\n // Chart margins for the axes, and the pixel width between bars\n margins: {\n left: 30,\n right: 20,\n top: 40,\n bottom: 40,\n between: 0.075,\n },\n colorScale: d3.scaleOrdinal([\n '#4e79a7', // Splits\n '#e15759', // Steals\n ]),\n labelColor: 'white',\n chartTitle: 'Split or Steal\\nper Contestant',\n showPercentages: true,\n };\n return makePieChart(subset.perContestant, config);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1173,"value":"$3e","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":236,"value":"Chart_2 = {\n // Get the applicable subset of data\n let subset = generateSubset_SplitOrSteals(dataset);\n \n // Create a convig variable with various chart properties\n let config = {\n // width x height of the chart canvas\n dimensions: {\n innerRadius: 90,\n outerRadius: 150,\n legendPaddingX: 10,\n legendPaddingY: 20,\n },\n // Chart margins for the axes, and the pixel width between bars\n margins: {\n left: 20,\n right: 200,\n top: 30,\n bottom: 40,\n between: 0.05,\n },\n colorScale: d3.scaleOrdinal([\n '#4e79a7', // Double split\n '#f28e2c', // Single steal\n '#e15759', // Double steal\n ]),\n labelColor: 'white',\n chartTitle: 'Split or Steal\\nper Episode',\n showPercentages: true,\n };\n \n return makePieChart(subset.perEpisode, config);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1224,"value":"SplitOrStealPerEpisode = md`\n## A deeper analysis of how often contestants cooperate\nBy adding a bit more complexity into our search, we can see a more clear representation of what really happened on the show. Among all the episodes, 30% of contestants shared the joy of a successful leap of faith, 25% both betrayed each other and destroying the jackpot (making the game show the real winner), and nearly half of the episodes result in a heartwrenching turn where the leap of faith is broken.\n\n## It is dangerous to oversimplify data\nIn the first chart, one may be misled in a variety of ways: does it mean nearly everyone who chooses steal wins everything? Are there only a few instances where both contestants choose to cooperate? While a baseline of 52% cooperation rate is a useful statistic, it leaves an incomplete perception of the data.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":324,"value":"Chart_3 = {\n // Get the applicable subset of data\n let subset = generateSubset_SplitPercentageVsJackpot(dataset);\n \n // Create a convig variable with various chart properties\n const config = {\n // width x height of the chart canvas\n dimensions: {\n width: 660,\n height: 500,\n },\n // Chart margins for the axes, and the pixel width between bars\n margins: {\n left: 50,\n right: 20,\n top: 40,\n bottom: 40,\n between: 20,\n },\n // A color scalar function that accepts a float input and outputs the corresponding color\n colorScale: d3.interpolateCool, // A d3-scale-chromatic scale of all cool colors\n axisLabels: {\n title: 'Likelihood for Contestants to Split vs. Jackpot Size',\n x: 'Jackpot size, £ (£1.00 ≈ $1.38)',\n y: 'Cooperation rate',\n },\n };\n \n // Generate and display the bar chart\n return makeBarChart(subset.percentages, config);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1286,"value":"$3f","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1279,"value":"Chart_4 = {\n // Get the applicable subset of data\n let subset = generateSubset_MaleVsFemale(dataset);\n \n // Create a convig variable with various chart properties\n const config = {\n // width x height of the chart canvas\n dimensions: {\n width: 600,\n height: 500,\n },\n // Chart margins for the axes, and the pixel width between bars\n margins: {\n left: 50,\n right: 20,\n top: 40,\n bottom: 40,\n between: 30,\n },\n // A color scalar function that accepts a float input and outputs the corresponding color\n colorScale: d3.scaleOrdinal(d3.schemePaired), // A color pair, which matches split/steal for male/female\n axisLabels: {\n title: 'Likelihood of Outcome vs. Gender',\n x: 'Gender - Final Outcome',\n y: 'Outcome likelihood',\n },\n };\n \n // Generate and display the bar chart\n return makeBarChart(subset, config);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1303,"value":"$40","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":720,"value":"Chart_5 = {\n // Get the applicable subset of data\n let subset = generateSubset_Education(dataset);\n \n // Create a convig variable with various chart properties\n const config = {\n // width x height of the chart canvas\n dimensions: {\n width: 600,\n height: 500,\n },\n // Chart margins for the axes, and the pixel width between bars\n margins: {\n left: 50,\n right: 20,\n top: 40,\n bottom: 40,\n between: 20,\n },\n // A color scalar function that accepts a float input and outputs the corresponding color\n colorScale: d3.scaleOrdinal(d3.schemeSet1), // A color pair, which matches split/steal for male and split/steal for female\n axisLabels: {\n title: 'Likelihood to Split vs. Education Type',\n x: 'Education Type',\n y: 'Cooperation rate',\n },\n };\n \n // Generate and display the bar chart\n return makeBarChart(subset.percentages, config);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1333,"value":"$41","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":725,"value":"Chart_6 = {\n // Get the applicable subset of data\n let subset = generateSubset_Age(dataset);\n \n // Create a convig variable with various chart properties\n const config = {\n // width x height of the chart canvas\n dimensions: {\n width: 650,\n height: 500,\n },\n // Chart margins for the axes, and the pixel width between bars\n margins: {\n left: 50,\n right: 20,\n top: 40,\n bottom: 40,\n between: 20,\n },\n // A color scalar function that accepts a float input and outputs the corresponding color\n colorScale: d3.scaleOrdinal(d3.schemeTableau10), // A color pair, which matches split/steal for male and split/steal for female\n axisLabels: {\n title: 'Likelihood to Split vs. Age',\n x: 'Age Group',\n y: 'Cooperation rate',\n },\n };\n \n // Generate and display the bar chart\n return makeBarChart(subset.percentages, config);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1362,"value":"Age = md`\n## Age is a direct, strong correlation with cooperation\nAs age increases, contestants approach a much higher rate of cooperation. I believe that older individuals are more financially secure, which means that extra money matters less to them. Similarly to how low stakes implied greater weight in external motivations, the social experience of trusting one another carries more weight with an increase in age.\n\nWhen individuals are young, money matters more: the extra funds from choosing \"steal\" could be the difference between affording a vacation, building up savings, or paying off debt. To younger contestants, these winnings are a significantly larger portion of their savings. (The show's producers made sure to vet anyone who was extremely poor or extremely wealthy, so prize winnings were never make-or-break nor meaningless to contestants.)\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":747,"value":"Chart_7 = {\n // Get the applicable subset of data\n let subset = generateSubset_ConversationStatements(dataset);\n \n // Create a convig variable with various chart properties\n const config = {\n // width x height of the chart canvas\n dimensions: {\n width: 900,\n height: 600,\n },\n // Chart margins for the axes, and the pixel width between bars\n margins: {\n left: 50,\n right: 20,\n top: 40,\n bottom: 40,\n between: 20,\n },\n // A color scalar function that accepts a float input and outputs the corresponding color\n colorScale: d3.scaleOrdinal(d3.schemeCategory10), // A color pair, which matches split/steal for male and split/steal for female\n axisLabels: {\n title: 'Likelihood to Split vs. Described Motivation in Final Conversation',\n x: 'Motivation Type Given',\n y: 'Cooperation rate',\n },\n };\n \n // Generate and display the bar chart\n return makeBarChart(subset.percentages, config);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1404,"value":"$42","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":846,"value":"Chart_8 = {\n // Get the applicable subset of data\n let subset = generateSubset_PredeterminedChoice(dataset);\n \n // Create a convig variable with various chart properties\n let config = {\n // width x height of the chart canvas\n dimensions: {\n innerRadius: 90,\n outerRadius: 150,\n legendPaddingX: 10,\n legendPaddingY: 20,\n },\n // Chart margins for the axes, and the pixel width between bars\n margins: {\n left: 20,\n right: 200,\n top: 30,\n bottom: 40,\n between: 0.05,\n },\n colorScale: d3.scaleOrdinal([\n '#22dd22', // Always split\n '#ffd300', // Uncertain - split\n '#f79b11', // Uncertain - steal\n '#ed371f', // Always steal\n ]),\n labelColor: 'black', // Fill color for numbers in the chart\n chartTitle: 'Was the\\nContestant\\'s\\nChoice\\nPredetermined?',\n showPercentages: false,\n };\n \n // Generate and display the bar chart\n return makePieChart(subset, config);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1490,"value":"WasChoicePredetermined = md`\n## Did the conversation even matter?\nThat last chart was a lot to take in, but it is certainly relevant. Before the show, producers confidentially asked contestants whether their mind was already made up on whether they'd split or steal. In 87% of cases, how a contestant's final opponent behaved throughout the show would influence the contestant's final choice. This means that contestants' actions leading up to and including the final conversation had a large influence on their opponent's choice.\n\nI was surprised to find out so few people would unconditionally pick steal, but this is good news! It means that, in most cases, an opponent's choice can often be influenced by building trust, or a lack thereof.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":797,"value":"Chart_9 = {\n // Get the applicable subset of data\n let subset = generateSubset_OppoentAttemptedVotingOff(dataset);\n \n // Create a convig variable with various chart properties\n const config = {\n // width x height of the chart canvas\n dimensions: {\n width: 600,\n height: 500,\n },\n // Chart margins for the axes, and the pixel width between bars\n margins: {\n left: 50,\n right: 20,\n top: 40,\n bottom: 40,\n between: 20,\n },\n // A color scalar function that accepts a float input and outputs the corresponding color\n colorScale: d3.scaleOrdinal([\n '#b2df8a',\n '#33a02c',\n '#fb9a99',\n '#e31a1c']), // Two color pairs for voted/not voted against\n axisLabels: {\n title: 'Outcome vs. Prior Betrayal by Opponent',\n x: 'If Opponent Voted Against Contestant - Final Outcome',\n y: 'Outcome likelihood',\n },\n };\n \n // Generate and display the bar chart\n return makeBarChart(subset, config);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1514,"value":"Betrayal = md`\n## An opponent betraying in earlier rounds made contestants less likely to cooperate\nIn the first 2 rounds leading up to the final round, a single elimination vote occured among all remaining contestants. This vote was typically motivated by removing killer balls and the worst golden balls from the jackpot pool.\n\nOn the occasion that an opponent tried unsuccessfully voting out the other finalist, a breakdown of trust occurred. Contestants who were previously voted against were 33% less likely to pick splitting the jackpot with their opponent compared to if they were not voted against.\n`\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1164,"value":"$43","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":869,"value":"Sources = md`\n# Sources\n\n#### Inspirational paper and dataset\n[Split or Steal? Cooperative Behavior When the Stakes Are Large](https://www.semanticscholar.org/paper/b478d7c439c7c17c169ca27f91dbf82505792096) \n(Martijn J. van den Assem, Dennie van Dolder, Richard H. Thaler) \n[Malleable Lies: Communication and Cooperation in a High Stakes TV Game Show](https://pubsonline.informs.org/doi/suppl/10.1287/mnsc.2018.3159) \n(Uyanga Turmunkh, Martijn J. van den Assem, Dennie van Dolder)\n\n*Thank you to Dennie van Dolder for providing me the paper's dataset. Without it, this project would not have been possible.*\n\n#### ObservableHQ code snippets\nhttps://observablehq.com/d/b8d262e46ca14f7c \nhttps://observablehq.com/d/40e99d4aa4cb276c \nhttps://observablehq.com/@d3/pie-chart \nhttps://observablehq.com/@jeantimex/simple-line-chart-with-axis-labels\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1623,"value":"AboutTheAuthor = md`\n## About the Author\nHi! My name is Kevin Kulp, and I'm a Game Design and Development student at Rochester Institute of Technology.\n\nThis is my first project in my IGME-460 class, Data Visualization. This project involved finding a real-world dataset, refining the dataset using a tool called [OpenRefine](https://openrefine.org/), building a data visualization on ObservableHQ, and writing up our findings.\n\nOverall, I am very happy with how this project turned out. I look forward to my future projects, which will incorporate elements of user interactivity into the visualizations.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1560,"value":"$44","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1168,"value":"dataset = d3.csvParse(await FileAttachment(\"dataset-malleable-lies.csv\").text(), rowConverter);","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":876,"value":"$45","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":77,"value":"$46","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":321,"value":"$47","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":108,"value":"$48","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":356,"value":"$49","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":694,"value":"$4a","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":713,"value":"$4b","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":732,"value":"$4c","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":750,"value":"$4d","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":258,"value":"$4e","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1584,"value":"$4f","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":1686,"value":"CustomCSS = html`\n\n`","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":858,"value":"IncludedLibraries = md`\n## Included Libraries\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":861,"value":"d3 = require(\"d3@5\")","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":864,"value":"d3Legend = require('d3-svg-legend') // Used for generating pie chart legends","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W50","stdlib":"1"}} 34:null