Basic Income - Households

1 collaborator

WHAT IS IT?

This model (and two related ones) are an attempt to see to what extent a basic income (BI), or other form of redistribution, and various forms of taxation have on the gini coefficient, which measures inequality (the higher the coefficient, the greater the economic inequality).

I wanted a way of testing various policies (e.g. taxing inheritances) to see if they made any difference to the gini coefficient relative to other policies. You can see the experiments I ran in BehaviorSpace (Tools -> BehaviorSpace). (What I found was that whether an inheritance tax makes any difference depends on the relative size of the average inheritance vs the average income.) These models were inspired by disagreements I had with others at NABIG (North American Basic Income Guarantee) Congress 2018. I don't think they're going to resolve any disagreements, though.

The model was designed for a ten-year period, with each step being one month, and ten years being 120 steps, but of course it can be run for shorter or longer periods as desired.

The gini coefficient is not going to be directly comparable to the gini coefficient in real life, since real-life economies are much more complex.

This version looks at households composed of one or two adults and 0–3 children, with no seniors or disabled people.

HOW IT WORKS

Each agent is a household, born with a set amount of wealth (randomly assigned based on parameters you choose). If the randomly assigned amount of wealth is negative, it is set to 1. If there are two adults in the household, the initial wealth is doubled (because the coding was originally written for individuals only). This is the household's inheritance. Agent colour is set at the beginning in quintiles from grey to black based on their initial wealth (black being the wealthiest quintile), after any inheritance tax that you set has been deducted.

Each patch has a random amount of income (employment income, investment income, etc.). If a randomly assigned income level is negative, it is set to 0. The patches are shaded green in quintiles, with the highest income quintile having the darkest shade of green. This is done once during setup since patch income does not change.

Each agent is randomly assigned to its own patch. On each step, the agent looks at the patch ahead, and moves to it if it is empty and its income is higher than the current patch. Then each agent rotates right 90° so that it faces a new direction on each step.

From there, each agent earns the monthly income for its patch, deducts its cost of living, and adds the rest to its total wealth. If the number of adults in the household is 2, the income is doubled (because the coding was originally written for individuals only). If the wealth drops below 0, the agent turns red and the wealth is reset to 1 so that the gini coefficient calculation works. For agents not in the red, agent colour is reset on every tick so that each wealth quintile has its own shade of grey, with the highest quintile being black.

The assumption is that most agents have enough income to live on (though some won't) and that they are not that mobile when it comes to work - if they see a better opening nearby they grab it but are otherwise stuck where they are. They are not perfectly capable of finding the highest paying patch nearby, but they do their best.

Note that the agents are perfectly rational when it comes to savings, and if they can afford it, never spend more than 75% of their income on living expenses. Obviously this is not the real world.

If there is an inheritance tax it is applied during setup. Income taxes are paid monthly along with income (one step = one month).

There is no inflation, increase in cost of living, or increase in income in the model. Nobody dies.

The gini coefficient is recalculated on each step.

HOW TO USE IT

Choose the number of households. This could be based on the job vacancy rate, so that the number of empty patches roughly represents the number of jobs available at any one time. Set the composition of the households (number of adults, number of children) in the code tab in the setup-turtles section. You can use census data to estimate the proportion of each household type.

Choose the average (mean, not median) annual individual income (which will be divided by 12 for monthly income) and inheritance, and choose how you want these to be distributed among the population (randomly, normally, or exponentially). You can base this on real life statistics for a given country if you like, or just make something up. If you are running the model for a ten year period you should probably adjust the mean inheritance to take into account that it is only inheritances for a shorter period, rather than a lifetime. (I divided my estimated mean inheritance/wealth by about 5 to take this into account.)

Choose the lowest monthly cost of living per adult, and whether you want it to be exactly the same for each agent or distributed normally around a mean, using the allow-varied-indiv-min-cost-of-living chooser. (My experience is it doesn't make any difference to the gini coefficient, but I wanted to try it to see, so I included it and kept it in.). The household cost of living will be calculated from this value (with an additional 67% for a second adult and the top-up-children amount for each child - both of these can be changed in the code tab in the ask-turtles section), or 75% of the after-tax income, whichever is greater.

Choose what if any taxation you want to impose on agents each month, and the rate for the highest tax bracket. There are five tax brackets for progressive and semi-progressive tax rates, and they are set in the code tab.

Choose what if any income redistribution you want to give to agents each year, and set the annual amount with the max-bi slider. Decide whether or not you want to set the income redistribution on a per-individual or per-family basis with the BI-unit chooser. Also, choose how much more to provide for each child as a percentage of what a single adult would get with the top-up-children slider. (As the model is written now, this amount per child will be equal to the increased cost of living per child, but that can be changed in the code tab in the ask-turtles section.)

An NIT is a negative income tax, which gives a tax-free basic income to anyone below a certain threshold. The threshold is based on the amount of BI and the after-tax income multiplied by the clawback - if the after-clawback after-tax income is higher than the BI, the agent gets nothing. If the after-clawback after-tax income is less than the BI, the agent gets the BI plus the difference. For example, if you set the annual BI to 18,000 and have a clawback of 2/3, an annual after-tax income of 27,000 or more will not qualify someone for an NIT top-up (18,000 - (27,000 * 2/3) = 0), but an annual after-tax income of 15,000 will qualify the individual for an additional 8,000 per year (18,000 - (15,000 * 2/3)), and an after-tax income of 24,000 will qualify the individual for an additional 2,000 per year (18,000 - (24,000 * 2/3)).

A universal demogrant is a tax-free amount given to everyone regardless of how high their income is. One version of a UD is the UBI-FIT: a universal basic income plus a flat income tax (e.g. UD = 50% of median income, with everything over that taxed at a flat 50%).

If you want income redistribution to be a negative income tax (NIT) with a clawback, set the clawback. If you don't want the clawback, set it at 0%.

(Welfare in Canada and the US is similar to a partial BI/NIT with a clawback. You can set the annual BI to be less than the annual monthly cost of living (minimum monthly cost of living times 12), if you want to make it more authentic.)

Run the scenario one step at a time, or indefinitely, or for 120 steps (the equivalent of 10 years at one step per month).

THINGS TO NOTICE

Does the gini coefficient go in one direction over time, or does it go in one direction and then the other? Does it level off?

Even if two scenarios produce similar gini coefficients, is there any difference in the percentage of agents who go into debt (agents who are red)?

How much does each scenario outcome vary when you repeat it multiple times?

EXTENDING THE MODEL

You can add more complex forms of taxation and/or redistribution if you want, particularly if you want to mimic a real life set of policies. You can also change the tax bracket tax rates in the code tab in the after-tax-proportion section.

You could also try to set the inheritance so that different agents receive it at different times, and it is taxed on receipt. This would probably be a good idea if you want to run it for a longer period than ten years.

There are two other models I wrote at the same time. One is just for individuals, and the other is individuals, but adding seniors and disabled people. None of them includes roommates, so you can try to set any of them so that if someone is in the red, they can try to find and link to a roommate among other agents to reduce their cost of living.

RELATED MODELS

This model was inspired by Wealth Distribution, but other than the calculation for the gini coefficient (which I blatantly copied), it is entirely new code. There are other models listed under economics in the modelling commons that include basic income, but I don't pretend to understand them.

I have written two other companion models: BasicIncome-seniors-disabled and BasicIncome-Individual.

CREDITS AND REFERENCES

Copyright Sarah Robertson 2019, except for the gini coefficient calculations, which are from the Wealth Distribution model by Uri Wilensky.

You can read up on the gini coefficient, or at least see why I'm using it, in the book The Spirit Level: Why more equal societies almost always do better, by Richard G. WIlkinson and Kate Pickett (2009).

Comments and Questions

Please start the discussion about this model! (You'll first need to log in.)

Click to Run Model

globals
[
  gini-index-reserve
  lorenz-points
  max-wealth
  min-wealth           ;; I included this so I could check to see if there were any negative values
  max-income
  min-income
  monthly-bi
  max-indiv-cost-of-living
  total-adults
]

patches-own
[
  patch-income      ;; the current amount of income on this patch
  monthly-income    ;; patch income / 12
]

turtles-own
[
  wealth                   ;; the amount of money a turtle has
  after-tax                ;; amount of income left after paying taxes
  min-indiv-cost-of-living ;; individual minimum cost of living based on minimum set on interface
  cost-of-living           ;; cost of living calibrated for family composition
  num-adults               ;; number of adults per household (set further down in code)
  num-children             ;; number of children per household (set further down in code)
]

;; the different family types, for setting the number of adults and children - this model leaves out roommates and extended family
breed [couples-no-children couple-no-children]
breed [couples-1-child couple-1-child]
breed [couples-2-children couple-2-children]
breed [couples-3-children couple-3-children]
breed [singles-no-children single-no-children]
breed [singles-1-child single-1-child]
breed [singles-2-children single-2-children]
breed [singles-3-children single-3-children]

;;;
;;; SETUP AND HELPERS
;;;

to setup
  clear-all
  ;; call other procedures to set up various parts of the world
  setup-patches
  setup-turtles
  update-lorenz-and-gini
  reset-ticks
end 

;; set up the initial amounts of income each patch has

to setup-patches
  ask patches
  ;; set up patch income random amount depending on distribution chosen
  [
    if income-distribution = "random"
      [
        set patch-income random (mean-indiv-annual-income * 2)
      ]
    if income-distribution = "normal"
      [
        set patch-income random-normal  mean-indiv-annual-income (mean-indiv-annual-income / 2) ;; latter value is an estimate of the standard deviation based on what the curve looks like
      ]
    if income-distribution = "exponential"
      [
        set patch-income random-exponential (mean-indiv-annual-income)
      ]
      ;; keep income ≥ 0
    if patch-income < 0
      [
        set patch-income 0
      ]
    ;; set colour so richer patches have darker colour (in quintiles)
    set max-income max [ patch-income ] of patches       ;; find highest income
    if patch-income < max-income * 1 / 5 [ set pcolor 58 ]   ;; colour patches based on income levels
    if patch-income >= max-income * 1 / 5 and patch-income < max-income * 2 / 5 [ set pcolor 57 ]
    if patch-income >= max-income * 2 / 5 and patch-income < max-income * 3 / 5 [ set pcolor 56 ]
    if patch-income >= max-income * 3 / 5 and patch-income < max-income * 4 / 5 [ set pcolor 55 ]
    if patch-income >= max-income * 4 / 5 [ set pcolor 54 ]
  ]
end 

;; set up the initial values for the turtle variables

to setup-turtles
  set-default-shape turtles "house"
  ;; determine composition of the different households based on demographics ( * .25 etc) entered here
  create-couples-no-children num-households * .25
  ask couples-no-children [
    set num-adults 2
    set num-children 0
  ]
  create-couples-1-child num-households * .10
  ask couples-1-child [
    set num-adults 2
    set num-children 1
  ]
  create-couples-2-children num-households * .11
  ask couples-2-children [
    set num-adults 2
    set num-children 2
  ]
  create-couples-3-children num-households * .05
  ask couples-3-children [
    set num-adults 2
    set num-children 3
  ]
  create-singles-no-children num-households * .39
  ask singles-no-children [
    set num-adults 1
    set num-children 0
  ]
  create-singles-1-child num-households * .06
  ask singles-1-child [
    set num-adults 1
    set num-children 1
  ]
  create-singles-2-children num-households * .03
  ask singles-2-children [
    set num-adults 1
    set num-children 2
  ]
  create-singles-3-children num-households * .01
  ask singles-3-children [
    set num-adults 1
    set num-children 3
  ]

  ask turtles [
    move-to one-of patches with [not any? turtles-here]
    ;; if cost of living is to vary randomly do that here, otherwise set it at the minimum cost of living
    ifelse allow-varied-indiv-min-cost-of-living [
    set min-indiv-cost-of-living random-normal min-monthly-cost-of-living-per-adult (min-monthly-cost-of-living-per-adult / 6)
      set max-indiv-cost-of-living max [min-indiv-cost-of-living] of turtles ]
    [ set min-indiv-cost-of-living min-monthly-cost-of-living-per-adult ]
    ;; adjust cost of living for family composition
    if num-adults = 1 [ set cost-of-living min-indiv-cost-of-living * ( 1 + ( num-children * top-up-children / 100 )) ]
    if num-adults = 2 [ set cost-of-living min-indiv-cost-of-living * ( 1.67 + ( num-children * top-up-children / 100 )) ]
    ;; determine wealth of individuals
    if inheritance-distribution = "random"     ;; wealth
    [
      set wealth random (mean-indiv-inheritance * 2)
    ]
    if inheritance-distribution = "normal"
    [
      set wealth random-normal mean-indiv-inheritance (mean-indiv-inheritance / 4) ;; latter value is an estimate of the standard deviation
    ]
    if inheritance-distribution = "exponential"
    [
      set wealth random-exponential (mean-indiv-inheritance)
    ]
    if wealth <= 0
    [
      set wealth 1
    ]
    ;; if there are two adults in a household, double the wealth
    if num-adults = 2 [ set wealth wealth * 2 ]
    ;; colour turtles according to their relative wealth (this is reset at every step)
    color-turtles
    ;; if there's an inheritance tax, tax wealth at the beginning during set up (if progressive, use quintiles to set tax rate)
    if inheritance-tax = "flat"
    [ set wealth wealth * ( 1 - max-tax-rate / 100 ) ]
    if inheritance-tax = "progressive"
    [ if color = 1 [ set wealth wealth * (1 - max-tax-rate / 100) ]
      if color = 2 [ set wealth wealth * (1 - 0.8 * max-tax-rate / 100) ]
      if color = 3 [ set wealth wealth * (1 - 0.6 * max-tax-rate / 100) ]
      if color = 4 [ set wealth wealth * (1 - 0.4 * max-tax-rate / 100) ]
      if color = 5 [ set wealth wealth * (1 - 0.2 * max-tax-rate / 100) ]
    ]
    ;; set the household monthly income at 1/12 of the patch income; double it for two-adult households
    set monthly-income patch-income / 12
    if num-adults = 2 [ set monthly-income monthly-income * 2 ]
    face one-of neighbors4
  ]
end 

;;;
;;; GO AND HELPERS
;;;

to go
  ask turtles
  [
    upgrade-income   ;; move to neighbouring patch if it has more income
    update-wealth    ;; add net income to wealth
    color-turtles    ;; set colour according to wealth quintile
  ]
  update-lorenz-and-gini
  set min-income min [ patch-income ] of patches
  set min-wealth min [ wealth ] of turtles
  tick
end 

to go-ten-years
  ask turtles
  [
    upgrade-income   ;; move to neighbouring patch if it has more income
    update-wealth    ;; add net income to wealth
    color-turtles    ;; set colour according to wealth quintile
  ]
  update-lorenz-and-gini
  tick
  if ticks = 120
  [
    reset-ticks
    stop
  ]
end 


;; determine the direction which is most profitable for each turtle in
;; the surrounding patches within one patch
;; the only way I could get this to work was to have them just check one direction per tick

to upgrade-income  ;; turtle procedure - move to a higher paying patch next door if you can
  let patch-income-ahead patch-income-at-angle 0
  ;; if patch ahead has a higher income, go to it; and either way, rotate right 90°
  if (patch-income-ahead > patch-income)
  [ if not any? other turtles-on patch-ahead 1
    [ forward 1 ]]
  rt 90
  set monthly-income patch-income / 12
  if num-adults = 2 [ set monthly-income monthly-income * 2 ]
end 

;; check out which neighbouring patch has the highest income (cribbed from ants)

to-report patch-income-at-angle [angle]
  let p patch-right-and-ahead angle 1
  report [patch-income] of p
end 

;; add monthly income to wealth and subtract cost of living; grade cost of living to income if high enough

to update-wealth
  ;; set income tax rate: after-tax = proportion of income left after paying taxes
  if income-tax = "none" [ set after-tax 1 ]
  if income-tax = "flat" [ set after-tax 1 - max-tax-rate / 100 ]
  if income-tax = "progressive with loopholes for rich"
  [
    set max-income max [ patch-income ] of patches * 2 / 12
    if monthly-income >= max-income * 4 / 5 [ set after-tax 1 - 0.6 * (max-tax-rate / 100) ]
    if monthly-income >= max-income * 3 / 5 and monthly-income < max-income * 4 / 5 [ set after-tax 1 - 0.8 * (max-tax-rate / 100) ]
    if monthly-income >= max-income * 2 / 5 and monthly-income < max-income * 3 / 5 [ set after-tax 1 - 0.6 * (max-tax-rate / 100) ]
    if monthly-income >= max-income * 1 / 5 and monthly-income < max-income * 2 / 5 [ set after-tax 1 - 0.4 * (max-tax-rate / 100) ]
    if monthly-income < max-income * 1 / 5 [ set after-tax 1 - 0.2 * (max-tax-rate / 100) ]
  ]
  if income-tax = "progressive no loopholes for rich"
  [
    set max-income max [ patch-income ] of patches * 2 / 12
    if monthly-income >= max-income * 4 / 5 [ set after-tax 1 - 1.0 * (max-tax-rate / 100) ]
    if monthly-income >= max-income * 3 / 5 and monthly-income < max-income * 4 / 5 [ set after-tax 1 - 0.8 * (max-tax-rate / 100) ]
    if monthly-income >= max-income * 2 / 5 and monthly-income < max-income * 3 / 5 [ set after-tax 1 - 0.6 * (max-tax-rate / 100) ]
    if monthly-income >= max-income * 1 / 5 and monthly-income < max-income * 2 / 5 [ set after-tax 1 - 0.4 * (max-tax-rate / 100) ]
    if monthly-income < max-income * 1 / 5 [ set after-tax 1 - 0.2 * (max-tax-rate / 100) ]
  ]
  ;; set redistribution
  if income-redistribution = "none"
  [
    set monthly-bi 0
  ]
  if income-redistribution = "universal demogrant"   ;; give everyone the same top-up
  [
    if num-adults = 1 [ set monthly-bi max-bi-indiv / 12 ]
    if num-adults = 2
    [
      if BI-unit = "BI by individual" [ set monthly-bi 2 * max-bi-indiv / 12 ]
      if BI-unit = "BI by family" [ set monthly-bi max-bi-family / 12 ]
    ]
  ]
  if income-redistribution = "NIT with clawback"   ;; calculate partial BI after clawback
  [
    if num-adults = 1 [ set monthly-bi max-bi-indiv / 12 ]
    if num-adults = 2
    [
      if BI-unit = "BI by individual" [ set monthly-bi 2 * max-bi-indiv / 12 ]
      if BI-unit = "BI by family" [ set monthly-bi max-bi-family / 12 ]
    ]
    ifelse (monthly-income * after-tax * (clawback / 100)) < monthly-bi   ;; is after tax income too high with clawback?, if not proceed
    [
      set monthly-bi monthly-bi - (monthly-income * after-tax * (clawback / 100))
    ]
    ;; for NIT, if after-tax income is too high, don't give a BI
    [
      set monthly-bi 0
    ]
  ]
  ;; update amount of BI with amount for children
  set monthly-bi monthly-bi + monthly-bi * num-children * top-up-children / 100
  ;; calculate new wealth
  ifelse ((monthly-bi + (monthly-income * after-tax)) * 3 / 4) < cost-of-living   ;; deduct cost of living
  [set wealth wealth + monthly-bi + (monthly-income * after-tax) - cost-of-living ]
  [set wealth wealth + monthly-bi + (monthly-income * after-tax / 4) ]
end 

to color-turtles
  set max-wealth  max [ wealth ] of turtles
    if wealth < max-wealth / 5
    [ set color 5 ]
    if (wealth >= max-wealth / 5 and wealth < max-wealth * 2 / 5)
    [ set color 4 ]
    if (wealth >= max-wealth * 2 / 5 and wealth < max-wealth * 3 / 5)
    [ set color 3 ]
    if (wealth >= max-wealth * 3 / 5 and wealth < max-wealth * 4 / 5)
    [ set color 2 ]
    if (wealth >= max-wealth * 4 / 5)
    [ set color 1 ]
    if wealth <= 0
    [
    set wealth 1
    set color red
    ]
end 

;; this procedure recomputes the value of gini-index-reserve
;; and the points in lorenz-points for the Lorenz and Gini-Index plots
;; it is taken directly from Uri Wilensky's Wealth Distribution ABM

to update-lorenz-and-gini
    let sorted-wealths sort [wealth] of turtles
  let total-wealth sum sorted-wealths
  let wealth-sum-so-far 0
  let index 0
  set gini-index-reserve 0
  set lorenz-points []

  ;; now actually plot the Lorenz curve -- along the way, we also
  ;; calculate the Gini index.
  ;; (see the Info tab for a description of the curve and measure)
  repeat count turtles [
    set wealth-sum-so-far (wealth-sum-so-far + item index sorted-wealths)
    set lorenz-points lput ((wealth-sum-so-far / total-wealth) * 100) lorenz-points
    set index (index + 1)
    set gini-index-reserve
      gini-index-reserve +
      (index / num-households) -
      (wealth-sum-so-far / total-wealth)
  ]
end 


; Copyright 1998 Uri Wilensky and 2018 Sarah Robertson
; See Info tab for full copyright and license.

There is only one version of this model, created over 6 years ago by Sarah Robertson.

Attached files

File	Type	Description	Last updated
Basic Income - Households.png	preview	Preview for 'Basic Income - Households'	over 6 years ago, by Sarah Robertson	Download

This model does not have any ancestors.

This model does not have any descendants.

NetLogo