[EM] Fwd: New Method?

[Forest Simmons]

Excuse the lack of examples; soon I will have an actual computer keyboard for typing messages (and more) thanks to a generous gift from a big hearted Santa Claus helper🧙‍♂️🎅🤶

... so soon you will see illustrative examples galore!

-------- Mensaje original --------

De: Forest Simmons <[hidden email]>

Fecha: 27/12/20 9:29 p. m. (GMT-08:00)

A:

CC: Kevin Venzke <[hidden email]>

Asunto: Fwd: New Method?

Below I have defined the directed distance d(x, y) from x to y as the length of the shortest directed path from x to y. (where length of a directed path is the sum of the weights of each step, and in this context the weight of a directed edge is the number of losing votes, i.e. resistance against the defeat represented by the edge).

A basic (directed distance) closed neighborhood centered at x, of radius r, denoted N(x, r), is ... 

the set of alternatives y such that d(x, y) is no greater than r.

New Method: 

Elect the alternative z for which the set undefeatedby(z) is contained in the smallest radius neighborhood possible.

The set undefeatedby(z) is the set of all alternatives that are not defeated by z, i.e. the alternatives that pairwise beat or tie z.

For each set H, let rad(H) = min{r | for some alternative t, the basic neighborhood N(t, r) contains H}.

So we can restate this method thusly:

Elect from the set W(x) = argmin(over x)

 of rad( undefeatedby(x)).

Note that if z1 covers z2,

then rad(undefeated(z1)) is no greater than

rad(undefeated(z2)),

So there is always an uncovered alternative in W(x).

In particular, if W(x) is a singleton (the generic case), then the unique, un-tied winner is uncovered, i.e. a Landau alternative.

It will be interesting to compare this method with the better known Beatpath description of CSSD.

---------- Forwarded message -------
Anybody Seen This Before?

On Sunday, December 27, 2020, Forest Simmons <[hidden email]> wrote:

Start by building a directed graph whose vertices are the alternatives under consideration, and edges are directed from winners to losers. Pairwise ties are represented by double arrows. The edges are weighted with the losing or tied votes. 

The length of a directed path is the sum of the weights of the traversed edges.

Define the directed distance d(x,y) from alternative x to alternative y as the length of the shortest directed path from  x to y, if there is one, else infinity.

The radius R(x, S) from x of a subset S of alternatives is the max (over y in S) of d(x, y). When S is the entire set of alternatives we abbreviate its radius from x as R(x).

Let T(x) be the number of ballots that do not rank x.

The Least Resistance Winner is the candidate that minimizes the sum T(x) + R(x).

Remark: for any uncovered candidate this sum is less than twice the number of ballots.

Comment: the truncation term T(x) in the sum is there to ensure that the method satisfies the Plurality Criterion.

----
Election-Methods mailing list - see https://electorama.com/em for list info

[Kristofer Munsterhjelm-3]

On 28/12/2020 07.06, Forest Simmons wrote:
> Excuse the lack of examples; soon I will have an actual computer
> keyboard for typing messages (and more) thanks to a generous gift from a
> big hearted Santa Claus helper🧙‍♂️🎅🤶
>
> ... so soon you will see illustrative examples galore!

With so many methods flying around, I feel like we could use an election
simulator to (at a glance) determine if they're monotone, strategy
resistant, etc.

It would also aid experimentation if it weren't too difficult to
implement methods in it (get the computer to do what you want it to).

What language would be the easiest for you to program in? I have both a
C/C++ infrastructure (https://github.com/kristomu/quadelect/) and some
unpublished Python code that could do the job.

-km
----
Election-Methods mailing list - see https://electorama.com/em for list info

[Jan Šimbera]

My Python library (https://github.com/simberaj/votelib) could provide

the basis for such an election simulator. The new methods could be easily

added alongside existing ones; the simulation core and criterion evaluator

would have to be added, but I'll be glad to help with that given a clearer idea.

True, running the simulations in pure Python will never be as fast, but I suppose

the gain in modifiability outweighs that - many of the methods being suggested

in this list could be implemented in just a few lines of code...

On Mon, Dec 28, 2020 at 11:27 AM Kristofer Munsterhjelm <[hidden email]> wrote:

On 28/12/2020 07.06, Forest Simmons wrote:
> Excuse the lack of examples; soon I will have an actual computer
> keyboard for typing messages (and more) thanks to a generous gift from a
> big hearted Santa Claus helper🧙‍♂️🎅🤶
>
> ... so soon you will see illustrative examples galore!

With so many methods flying around, I feel like we could use an election
simulator to (at a glance) determine if they're monotone, strategy
resistant, etc.

It would also aid experimentation if it weren't too difficult to
implement methods in it (get the computer to do what you want it to).

What language would be the easiest for you to program in? I have both a
C/C++ infrastructure (https://github.com/kristomu/quadelect/) and some
unpublished Python code that could do the job.

-km
----
Election-Methods mailing list - see https://electorama.com/em for list info

----
Election-Methods mailing list - see https://electorama.com/em for list info