The Ruthless Boardroom: A Game of Capital Allocation

The Puzzle

A company generating an exceptionally high Return on Equity (ROE) has a surplus of 100 million rupees in unallocated capital. The board consists of 5 directors, ranked strictly by seniority from 1 (the CEO) down to 5 (the newest director).

To allocate the capital, the company bylaws dictate a strict protocol:

1. The most senior director proposes a specific capital allocation plan (how the 100 million is divided among the 5 members, in increments of 1 million).
2. All current board members (including the proposer) vote on the plan.
3. If the plan receives 50% or more of the votes, it is executed, and the game ends.
4. If it fails, the proposer is immediately ousted from the board for lacking management integrity. The next most senior director then takes over, proposing a new plan for the remaining members.

These board members are perfectly rational economic actors. Their priorities, in strict order, are:

1. Survival: Remain on the board.
2. Greed: Maximize their own share of the capital.
3. Spite: If survival and capital are equal, they prefer to oust a more senior member.

What proposal should the CEO (Director 1) make to maximize their capital while ensuring they are not ousted?

Formalization

Let the actors be $A, B, C, D, E$ (where $A$ is Director 1, $E$ is Director 5). Total capital $C = 100$. A proposal is a vector $(a, b, c, d, e)$ such that the sum is 100. The acceptance threshold is $V \ge \lceil N / 2 \rceil$ where $N$ is the number of remaining actors.

def calculate_allocation(num_directors, total_capital):
    # Base case: 1 director gets everything
    payouts = [total_capital] 
    
    for i in range(2, num_directors + 1):
        votes_needed = i // 2 + 1
        new_payouts = [0] * i
        
        # Sort previous payouts to find the cheapest votes to buy
        # We pair the previous payouts with their indices
        indexed_payouts = sorted(enumerate(payouts), key=lambda x: x[1])
        
        capital_spent = 0
        votes_secured = 1 # The proposer always votes for themselves
        
        for index, prev_amount in indexed_payouts:
            if votes_secured < votes_needed:
                # Buy the vote for 1 more than they would get otherwise
                # (Due to the "spite" rule, giving them exactly prev_amount means they vote no)
                cost = prev_amount + 1 
                new_payouts[index + 1] = cost
                capital_spent += cost
                votes_secured += 1
            else:
                new_payouts[index + 1] = 0
                
        new_payouts[0] = total_capital - capital_spent
        payouts = new_payouts
        
    return payouts

print(calculate_allocation(5, 100))
# Output: [98, 0, 1, 0, 1]