Q270 – Computational Models of Collective Behavior

Professor Robert Goldstone

Part A.

In the “Collective sum” game that you participated in, your task was to contribute a number to the group’s total (the sum of everybody’s contributions) so that the group’s total equaled a randomly selected target value. After each round, you received either “too high/too low” feedback, or numeric feedback telling you how far off (positive or negative) the group’s sum was compared to the computer’s selected number.

Question 1: Describe an algorithm that, if it were followed by each of the agents in a group, would allow the group to efficiently sum to the mystery number in the “too high/too low” feedback condition. If each agent randomly guesses a number on each round, the group would eventually stumble on the right sum, but this wouldn’t be very efficient. Describe an algorithm that would typically find solutions in less than 10 rounds. You don’t have to provide any computer programming, but you should describe the algorithm explicitly enough so that one could easily imagine how it might be implemented in a program.

Question 2: In Question 1, I had you describe an algorithm that was followed by each of the agents. However, having variability in the algorithms used by agents might actually speed up the time required for the group to find a solution. Why might this be the case? Explain by describing exactly how algorithmic variability could be introduced, and why this would be expected to have a beneficial effect.

Part B.

Your second assignment is to make a Netlogo program a physics model called alternatively “Ising model” or “Spin-glass.” Here’s a description of the model, using a socio-political scenario:

People start with random political affiliations (Democrat or Republican), and the people are spatially positioned in a grid. Each person has 8 neighbors. If a person has more Democratic neighbors than Republican neighbors, then the person buckles under the peer pressure, and becomes Democrat. If a person has more Republican neighbors, they become Republican. If a person has 4 of each kind of neighbor, they stay whatever they were before.

Design a Netlogo simulation for this set of rules. Given this rule set, if you start with the pattern at Time 1, then it should look like the pattern shown in Time 2 after applying the rules once:

All of the Democrats are shown by white squares, and all the republicans are shown by black squares.

Hint 1: You don’t need to use turtles at all for this simulation; you’ll only need to worry about patches.

Hint 2: Here is a set up routine you can use to randomly create political affiliations:

Patches-own [party]

to setup

ca

ask patches [ifelse (random 100) < density

[set party 1] [set party 0]

ifelse party = 1 [set pcolor yellow] [set pcolor blue]]

end

This assumes that you have a slider called “density” that goes from 0 to 100.

Hint 3: Each patch should own a variable: party . This variable says whether the patch is Democrat (1) or Republican (0). In my program, I also create a temporary variable for each patch, “sumz,” that contains the sum of the party variables of its neighbors, and accordingly looks like

[let sumz (nsum party)

if sumz < 4…]

Hint 4: You’ll definitely want to use the “nsum” command, and you’ll probably need at least one “if” or “ifelse” statement. The whole program will be about 4 lines long.

Question 1: Show your whole Netlogo program

Question 2: Given random configurations with 50% Democrat density, what happens over time? Describe why, as a first pass, this is a reasonable model of how Democrats and Republicans are distributed across the country.

Question 3: Now, allow your patches to assert their individuality. Add some random noise to your simulation - so that even if all of one’s neighbors are Democrats, one still could be Republican. So, instead of the statement:

[let sumz (nsum party) if sumz <4].... like you probably had earlier, use a command like:

[let sumz (nsum party) + (random randomness) – (random randomness)

if sumz < 4…]

What this code does is it creates a “noisy” sum of patches that is the actual sum of party states plus a bit of randomness minus a bit of randomness. You’ll also need to create a slider called “randomness” with a range from 0 to about 10. Start with a random configuration with a density of 50%. As you increase randomness (individuality) from 0 to 3, how does the distribution of democrats and republicans change? Do the party regions become larger or smaller as randomness increases? WHY?

Question 4: With randomness set to 2, what happens over time if the initial density of democrats is 56%? Repeat the simulation several times. This behavior is reasonable for some situations, but it doesn’t seem like a good behavior for simulating political parties. WHY NOT?