(contd from last)
Now suppose that we look at IRV for four candidates. The expression
becomes a big mess:
if fpA > fpD and fpB > fpD and fpC > fpD then D is eliminated first and
A's score is g(H(fpDE_A - fpDE_C) * H(fpDE_B-fpDE_C) * A>B, H(fpDE_A -
fpDE_B) * H(fpDE_C - fpDE_B) * A>C),
similarly for all other elimination orders
where fpDE_A is A's first preferences after D is eliminated. I.e. with
fpDE_A = ABCD + ABDC + ACBD + ACDB + ADBC + ADCB + DABC + DACB.
Things get hairy real quick and that was just one case. So I found out
it's much easier to define f recursively. Let e\A be the election e
after A has been eliminated. Then for candidates > 3, and assuming that
g is associative and distributive over multiplication:
f(A, e) = g( H(fpA-fpD) * H(fpB-fpD) * H(fpC-fpD) * f(A, e\D),
...
H(fpA-fpB) * H(fpC-fpB) * H(fpD-fpB) * f(A, e\B))
Now I think we could use the same trick as before with introducing fpA
to make the terms that don't already contain fpA monotone:
f(A, e) = g( H(fpA-fpD) * H(fpA+fpB-fpD) * ... * f(A, e\D) ...)
and the same cancellation happens here, so this method is then
recursively defined as
f(A, e) = g( H(fpA-fpB) * f(A, e\B),
H(fpA-fpC) * f(A, e\C),
H(fpA-fpD) * f(A, e\D))
for four candidates,
which should be monotone and might be interesting; although
(depending on just how g is defined), calculating the score might
require 2^c base case calls due to the recursive blowup!
-km
(contd from last)
Now suppose that we look at IRV for four candidates. The expression
becomes a big mess:
if fpA > fpD and fpB > fpD and fpC > fpD then D is eliminated first and
A's score is g(H(fpDE_A - fpDE_C) * H(fpDE_B-fpDE_C) * A>B, H(fpDE_A -
fpDE_B) * H(fpDE_C - fpDE_B) * A>C),
similarly for all other elimination orders
where fpDE_A is A's first preferences after D is eliminated. I.e. with
fpDE_A = ABCD + ABDC + ACBD + ACDB + ADBC + ADCB + DABC + DACB.
Things get hairy real quick and that was just one case. So I found out
it's much easier to define f recursively. Let e\A be the election e
after A has been eliminated. Then for candidates > 3, and assuming that
g is associative and distributive over multiplication:
f(A, e) = g( H(fpA-fpD) * H(fpB-fpD) * H(fpC-fpD) * f(A, e\D),
...
H(fpA-fpB) * H(fpC-fpB) * H(fpD-fpB) * f(A, e\B))
Now I think we could use the same trick as before with introducing fpA
to make the terms that don't already contain fpA monotone:
f(A, e) = g( H(fpA-fpD) * H(fpA+fpB-fpD) * ... * f(A, e\D) ...)
and the same cancellation happens here, so this method is then
recursively defined as
f(A, e) = g( H(fpA-fpB) * f(A, e\B),
H(fpA-fpC) * f(A, e\C),
H(fpA-fpD) * f(A, e\D))
for four candidates,
which *should* be monotone and *might* be interesting; although
(depending on just how g is defined), calculating the score might
require 2^c base case calls due to the recursive blowup!
-km
