[EM] SODA

[Jameson Quinn]

I would like to keep generic SODA as simple as possible, to make it easier
to promote for practical use. However, I am still interested in figuring out
the best possible SODA+ method, using DSC or whatever.

For generic SODA, the current rule is: candidates exercise their ballots in
descending order of current approval score. This will correctly get the CW
in all 3-candidate scenarios (including non-delegable votes), and I suspect
in all 4-candidate scenarios without delegable votes and full ranking. (I
can get a very fragile non-CW scenario for 5 candidates, all-delegable
votes, and full ranking, in a (1+*2*)v(2) clone scenario, where the CW is
one of the starred 2.) Note that, simple as it is, this rule tends to
"follow clone sets down", as Forest's proposed rules do, because if A
delegates to B, then B is almost certain to go next. Thus, this rule is
highly clone resistant, for reasonable numbers of clones, although not
perfectly clone-proof. It is also clone-proof (ie, IIA) for 1D scenarios.

I'd like to make some Yee diagrams for SODA with this rule. Does anybody
know what algorithms I could use? It would be pretty easy if you assumed
that all voters gave a delegable vote; but I think that a more realistic
rule would be that voters give a delegable vote iff they agree with their
preferred candidate's first delegation, and approves the top max(2
candidates or 1/3 of all candidates) if not. That, plus the delegation
order, is getting a bit hairy for calculating Yee diagrams from, so I'd
appreciate any tips on algorithmic short cuts. (eg, is there some way to
prove that this voting rule in a 2-dimensional space always gives a
ballot-CW under SODA, and that therefore I can avoid dealing with delegation
order?). If the diagrams can be calculated relatively quickly, I'd be
interested in doing this using a real-time web tool (as an excercise in
programming in go with GAE); otherwise, I could do it in whatever language,
offline.

As for Forest's DSC rule for SODA+: how about starting with the DSC winner,
then proceeding to the DSC winner among those who got votes from the last
player, or the DSC winner among the remainder if the last player did not
assign votes? It's in effect similar to the "higest ranking from the
previous player" rule, but closer to the "generic SODA" rule.

JQ

ps. I vaguely know how DSC works, but I'd appreciate a refresher.

2011/7/20 <fsimmons at pcc.edu>

> In our SODA development we came to something of an impasse for determining
> the "order of play" for
> the candidates casting their approval cutoffs.
>
> Here's a suggestion:
>
> Let the DSC winner go first, because the DSC winner is easily calculated,
> satisfies Later-No-Harm (so
> does not unduly encourage truncation), and can be thought of as the minimal
> acceptable modification of
> plurality, namely de-cloning it without destroying its montonicity.  In a
> way, DSC elegantly
> accomplishes what IRV attempts but botches.
>
> [In the context of SODA where there is only one faction for each of the n
> candidates, the DSC method
> has to score at most n*(n-1) subsets, and it takes no more than the order
> of n^2 steps to determine the
> DSC score of each of these subsets.  So the whole thing can be done in the
> order of n^4 steps at worst.]
>
> From then on the next player in the sequence is the candidate that ranked
> the previous player X the
> highest. If there is a tie, say Y1, Y2, and Y3 each ranks X equally high
> (and higher than anybody else
> does) then the member of {Y1, Y2, Y3} ranked highest by X is the next
> player.
>
> This order is clone consistent, i.e. if Y is replaced by a clone set, then
> the entire clone set will be
> intercalated into the order in place of Y.
>
> This order discourages burial, because if X is first in the order, and Y
> buries X,  then Y will not follow X,
> unless all of the other candidates bury X, too, in which case X could not
> have been first.
>
> Note that we could reverse the roles of X and Y in determining the order
> and breaking ties:  The
> remaining candidate Y that X ranks the highest is next, and if X ranks no
> remaining candidate, then the
> candidate that ranks X the highest is next.  My intuition is that this
> order might not be quite as burial
> resistant, but it would be better at discouraging what we could call
> "fawning," namely ranking the
> presumed DSC winner artificially high for the sole purpose of getting into
> the order earlier.
>
> Another option would be to use the DSC winner's rankings for all of the
> rest of the players, and passing
> to the second player's rankings to resolve any equal rankings made by the
> DSC winner, etc.
>
> We need to experiment to see if any of these is adequate, and if so, which
> is best.
>
> What are some good scenarios to test?
>
>
> ----
> Election-Methods mailing list - see http://electorama.com/em for list info
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.electorama.com/pipermail/election-methods-electorama.com/attachments/20110720/80bab2f5/attachment-0004.htm>