The below Python code runs a simulation of a world without any norms. The resources distribution tends to winner takes all scenario with increasing number of turns.
The simulated world has the following properties:
1. You can invest resources to get even more resources. Therefore, people can multiply their resources at exponential rate. Examples:
1. You can invest computational power to get more artificial intelligence which you can invest to get more computational power.
2. You can invest political power to get more media influence which you can invest to get more political power.
2. There is scarcity of resources, so people compete for resources. Example:
1. It might be easier for a person to acquire new land by taking it from someone else than for example by colonizing Mars.
3. There is some luck involved in who will acquire the resources.
Update:
I think that I made a mistake in the assumptions - I didn't take into account that there are diminishing returns when it comes to using resources. But even if we include that, the conclusion should stay the same.
Note: the below code has been generated using an artificial intelligence model.
```Python
import random
import matplotlib.pyplot as plt
def run_simulation(n, x, r_min, r_max, turns, terminate_when_winner=False,
winner_threshold=0.99):
# Initialize resources for each player with the same constant value x.
resources = [x] * n
# Record resource history for plotting.
resource_history = [[] for _ in range(n)]
total_resources_history = []
print("Initial resource distribution:")
for i, res in enumerate(resources):
print(f"Player {i + 1}: {res:.2f}")
for turn in range(turns):
# Choose a random multiplier for this turn.
current_r = random.uniform(r_min, r_max)
# Save the current resources before multiplication.
old_resources = resources.copy()
# Multiply each player's resources by the random multiplier.
resources = [res * current_r for res in resources]
# Calculate the increase ("addition") for each player.
additions = [new - old for new, old in zip(resources, old_resources)]
# For each addition, choose a random player and deduct addition / 2 from that player's resources.
for add in additions:
idx = random.randrange(n)
deduction = add / 2
resources[idx] = max(0, resources[idx] - deduction)
# Record each player's resources.
for i in range(n):
resource_history[i].append(resources[i])
total_resources_history.append(sum(resources))
# Optionally, check for early termination if one player's share exceeds the threshold.
total = sum(resources)
if terminate_when_winner and total > 0:
max_share = max(resources) / total
if max_share >= winner_threshold:
print(
f"Terminating at turn {turn} as one player reached {max_share:.2%} of total resources.")
break
return resources, resource_history, total_resources_history
def plot_results(resource_history):
turns = len(resource_history[0])
plt.figure(figsize=(12, 6))
# Plot the resource trajectories for each player.
for i, history in enumerate(resource_history):
plt.plot(history, label=f'Player {i + 1}')
plt.xlabel("Turn")
plt.ylabel("Resources")
plt.title("Resource Accumulation per Player Over Time")
plt.legend()
plt.grid(True)
plt.show()
def main():
# Simulation parameters
n = 5 # number of players
x = 100 # initial constant resources for each player
r_min = 0.75 # minimum multiplier factor per turn
r_max = 1.5 # maximum multiplier factor per turn
turns = 5000 # number of simulation turns
terminate_when_winner = True
final_resources, resource_history, total_resources_history = run_simulation(
n, x, r_min, r_max, turns, terminate_when_winner
)
total = sum(final_resources)
print("\nFinal resource distribution:")
for i, res in enumerate(final_resources):
share = (res / total) * 100 if total > 0 else 0
print(f"Player {i + 1}: {res:.2f} resources ({share:.2f}%)")
# Plot the resource trajectories per player.
plot_results(resource_history)
if __name__ == '__main__':
main()
```
Output (there is randomness involved so you might get slightly different result):
![[Winner takes all.png]]