# Wealth distribution model

This model is a simple agent-based economy that is modelled according to the work of Dragulescu et al.. This work introduces statistical mechanics concepts to study wealth distributions. What we show here is also referred to as "Boltzmann wealth distribution" model.

This model has a version with and without space. The rules of the space-less game are quite simple:

1. There is a pre-determined number of agents.
3. At every step an agent gives 1 unit of wealth (if they have it) to some other agent.

Even though this rule-set is simple, it can still recreate the basic properties of wealth distributions, e.g. power-laws distributions.

## Core structures: space-less

We start by defining the Agent type and initializing the model.

using Agents
mutable struct WealthAgent <: AbstractAgent
id::Int
wealth::Int
end

Notice that this agent does not have a pos field. That is okay, because there is no space structure to this example. We can also make a very simple AgentBasedModel for our model.

function wealth_model(; numagents = 100, initwealth = 1)
model = ABM(WealthAgent, scheduler = random_activation)
for i in 1:numagents
end
return model
end

model = wealth_model()
AgentBasedModel with 100 agents of type WealthAgent
no space
scheduler: random_activation

The next step is to define the agent step function

function agent_step!(agent, model)
agent.wealth == 0 && return # do nothing
ragent = random_agent(model)
agent.wealth -= 1
ragent.wealth += 1
end

We use random_agent as a convenient way to just grab a second agent. (this may return the same agent as agent, but we don't care in the long run)

## Running the space-less model

Let's do some data collection, running a large model for a lot of time

N = 5
M = 2000
model = wealth_model(numagents = M)
data[(end - 20):end, :]

21 rows × 3 columns

stepidwealth
Int64Int64Int64
1519801
2519811
3519820
4519832
5519842
6519850
7519861
8519870
9519882
10519891
11519900
12519910
13519923
14519935
15519942
16519951
17519960
18519970
19519983
20519991
21520000

What we mostly care about is the distribution of wealth, which we can obtain for example by doing the following query:

wealths = filter(x -> x.step == N - 1, data)[!, :wealth]
2000-element Array{Int64,1}:
4
4
1
0
2
0
1
2
1
1
⋮
3
5
1
0
0
1
0
2
1

and then we can make a histogram of the result. With a simple visualization we immediately see the power-law distribution:

using UnicodePlots
UnicodePlots.histogram(wealths)
              ┌                                        ┐
[0.0, 1.0) ┤▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 894
[1.0, 2.0) ┤▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇ 587
[2.0, 3.0) ┤▇▇▇▇▇▇▇▇▇▇▇ 278
[3.0, 4.0) ┤▇▇▇▇▇▇ 154
[4.0, 5.0) ┤▇▇ 59
[5.0, 6.0) ┤▇ 15
[6.0, 7.0) ┤ 7
[7.0, 8.0) ┤ 6
└                                        ┘
Frequency

## Core structures: with space

We now expand this model to (in this case) a 2D grid. The rules are the same but agents exchange wealth only with their neighbors. We therefore have to add a pos field as the second field of the agents:

mutable struct WealthInSpace <: AbstractAgent
id::Int
pos::NTuple{2,Int}
wealth::Int
end

function wealth_model_2D(; dims = (25, 25), wealth = 1, M = 1000)
space = GridSpace(dims, periodic = true)
model = ABM(WealthInSpace, space; scheduler = random_activation)
for i in 1:M # add agents in random nodes
end
return model
end

model2D = wealth_model_2D()
AgentBasedModel with 1000 agents of type WealthInSpace
space: GridSpace with 625 nodes and 1250 edges
scheduler: random_activation

The agent actions are a just a bit more complicated in this example. Now the agents can only give wealth to agents that exist on the same or neighboring nodes (their "neighbors").

function agent_step_2d!(agent, model)
agent.wealth == 0 && return # do nothing
agent_node = coord2vertex(agent.pos, model)
neighboring_nodes = node_neighbors(agent_node, model)
push!(neighboring_nodes, agent_node) # also consider current node
rnode = rand(neighboring_nodes) # the node that we will exchange with
available_ids = get_node_contents(rnode, model)
if length(available_ids) > 0
random_neighbor_agent = model[rand(available_ids)]
agent.wealth -= 1
random_neighbor_agent.wealth += 1
end
end

## Running the model with space

init_wealth = 4
model = wealth_model_2D(; wealth = init_wealth)
data, _ = run!(model, agent_step!, 10; adata = adata, when = [1, 5, 9])
data[(end - 20):end, :]

21 rows × 4 columns

stepidwealthpos
Int64Int64Int64Tuple…
199802(10, 23)
299815(21, 1)
399822(18, 13)
499832(24, 7)
599841(24, 1)
699853(4, 10)
799863(5, 5)
899876(21, 6)
999884(11, 18)
1099896(19, 16)
1199901(14, 25)
1299913(17, 20)
1399924(25, 22)
1499935(24, 1)
1599949(16, 13)
16999510(1, 18)
1799965(19, 22)
1899978(21, 2)
1999984(6, 21)
2099990(13, 1)
21910004(2, 7)

Okay, now we want to get the 2D spatial wealth distribution of the model. That is actually straightforward:

using Plots

function wealth_distr(data, model, n)
W = zeros(Int, size(model.space))
for row in eachrow(filter(r -> r.step == n, data)) # iterate over rows at a specific step
W[row.pos...] += row.wealth
end
return W
end

W1 = wealth_distr(data, model2D, 1)
Plots.heatmap(W1)
W5 = wealth_distr(data, model2D, 5)
Plots.heatmap(W5)
W10 = wealth_distr(data, model2D, 9)
Plots.heatmap(W10)

What we see is that wealth gets more and more localized.