Chores assignment calculator
============================

This small program (laske.py) counts who should do which housekeeping
chore.  It is based on the idea that equality between people mandates
that everybody should do the same amount of work, but people's
subjective opinion on the ease of a given task varies quite a lot.

How do I use it?
----------------

The program is run as in:

$ python laske.py painot1.csv

In the input, each task/chore is on its own row, and each column
corresponds to a person, and the numbers on the rows give the subjective
burden of doing that chore for that particular person.  From this
information, the program tries to find a set of chore assignments with
the following properties:

- the distribution of work is as equal as possible; everybody gets the
  same subjective burden.
- the utility of the division of labor is as high as possible; the
  chores are assigned to the person who finds them the least
  objectionable.

Also, if you do _not_ want an equal division, name the first line
"burden_factor".  With this line, you can set the target ratio of work
for different people.  For instance, "burden_factor,2,1,1,1" means that
the first person should get twice as much work (subjectively) as each of
the other three.  See `painot5.csv` for an example.

The output of the program is a series of (improving) work assignments.
For each assignment, the program first report the percentages how much
of a given chore should be handled by which person, and then a
table of the subjective burdens those chores cause for each participant.

How does it work?
-----------------

The algorithm is approximately as follows:

1. Scale all the "subjective burden" numbers so that each person has the
same total, i.e., if all work was assigned to one person only, then the
subjective burden will be the same whoever it is.

2. Create a distribution of work that assigns every task to the person
for whom the task is least work (subjectively).

3. Starting from that distribution, run a genetic search for a
distribution that minimises badness.  Badness is defined as:

badness = sum(w_p) + std_dev(w_p / bf_p)
where w_p = subjective work burden for person p
  and bf_p = the target burden factor for person p

The terms correspond to utility (sum(w_p)) and equality (std_dev(w_p)).

Tweaking
--------

`laske.py` has some parameters at the beginning of the file that you can
edit if you want it to work differently.