Thanks for opening up new vistas!

How about restricting method X to Smith?

Or using some other method to pare down the field to manageable size?

On Tue, Aug 1, 2023, 4:21 PM Kristofer Munsterhjelm km_elmet@t-online.de
wrote:

On 8/2/23 07:07, Forest Simmons wrote:

It's even more strange if I do so. Here's Smith//X:

Burial, no compromise:  4262    0.0875496
Compromise, no burial:  9268    0.190382
Burial and compromise:  1933    0.0397075
Two-sided:              8103    0.166451
Other coalition strats: 0      0

---=========
Manipulable elections:  23566  0.48409

See how there's no "Other"? So it too most likely is monotone! Just how
is that possible? Schwartz//X is monotone too.

(I don't think the difference between manipulability here and for
Smith,IRV is significant, as much as it would be fun to say I've not
just met but beat IRV :-)

I tried to check Landau//X. It had plenty of Other strats, which is not
unexpected given your proof about independence of covered alternatives
plus first preference tiebreak implying nonmonotonicity... but I think
my implementation of Landau is suspect, so I'm not including it here.

I could try other variants like "whenever someone is eliminated,
everybody he beats pairwise must also be eliminated". If that were done
on a global ordering (like IRV), that should give us Landau (and
Banks?), but I don't know if our method construction guidelines still
hold when the elimination order is different for different candidates.
This is rather uncharted territory!

-km

On Tue, Aug 1, 2023, 4:21 PM Kristofer Munsterhjelm km_elmet@t-online.de
wrote:

This DSV feature could be the key to overcoming our main objection to Asset
Voting ... the loose cannon proxy.

Restricting to Smith requires lots of first place vote transfers ... right?

So what about (for each candidate X) just bequeathing all of X's first
place assets to the Smith member Y against which X has the fewest losing
votes?

And how about applying this idea more generally to restrict Asset DSV to
Smith?

On Wed, Aug 2, 2023, 4:15 AM Kristofer Munsterhjelm km_elmet@t-online.de
wrote:

On Tue, Aug 1, 2023, 4:21 PM Kristofer Munsterhjelm km_elmet@t-online.de
wrote:

The reason Kemeny is computationally intractable is the sheer number of
finish orders that have to be checked to make sure you got the one that
minimizes the sum of the Kendall-tau distances (or swap cost metrics for my
Cline independent version) to the ballot rankings. Computing the swap cost
metric sum for any given finish order is cheap(in both time and space).

So the simplest way to get the strategy resistant benefit of the method is
to allow voters, candidates, and other stake holders to each submit several
thousand finish orders, and then generate several trillion more at random
... and then quickly compute the minimal cost solution restricted to these
few trillions of proposals.

It seems to me that the same idea would make Method X "approximately
tractable." In other words, MonteCarlo plus unlimited (but not by bots)
stake holder submissions.

On Wed, Aug 2, 2023, 4:15 AM Kristofer Munsterhjelm km_elmet@t-online.de
wrote:

Let M be the matrix whose (j,k) element is one (else zero) if candidate j
defeats candidate k.

Then candidate j is uncovered iff the j_th row of (I+M)^2 is devoid of
zeros  ... because the (j,k) element of this matrix is the number of
distinct short beatpaths (i.e. of length 0,1, or 2) from candidate j to
candidate k.

Responding to both DSV posts in one message...

On 8/2/23 14:46, Forest Simmons wrote:

I'm not entirely sure how, could you explain? I can maximize for A
because I can infer what A's trying to maximize (his score) and the
means by which it can be done (choosing a particular sequence of
eliminations).

But in Asset Voting (and delegable proxy) it would seem like the main
benefit is that you can't specify your preferences in exact detail, so
you instead choose to give your voting power to someone who can.

Then the loose cannon is a problem where someone you trusted goes and
does the wrong thing. Because the system doesn't know your preferences
(if it did, you wouldn't need to use a proxy), it can't preemptively
optimize around the "glitches".

Or am I thinking of something entirely different?

Yeah, that's right; that's why it's so surprising that Smith//X would
stay monotone. Dropping a bunch of non-Smith candidates changes the lay
of the land in unpredictable ways -- yet apparently not so unpredictable
that monotonicity is affected. "Where is the deeper pattern in this chaos?"

You mean for making a simpler method that still passes Smith and ISDA?
Smith//X would automatically remove all non-Smith members before doing
X, and method X itself finds a maximally beneficial elimination order
for each candidate, thus doing something disadvantageous to candidate X
wouldn't seem to have a place in that procedure.

-km

On 8/2/23 16:24, Forest Simmons wrote:

Yes, you could deal with it that way in practice, possibly combined with
a restriction to the Smith set. Since there doesn't seem to be any
monotonicity drawback to just using Smith//X here, and most (current)
public elections would have a very small Smith set, in the vast majority
of cases exhaustive calculation would suffice.

Just like Kemeny :-)

There's a part of me that likes mathematical elegance, that would like
to find something that's to this method what Ranked Pairs is to Kemeny:
preserving its unique property (LIIA or monotone burial resistance)
while improving on it (by being polytime).

But I shouldn't let that devalue the significance of finding method X in
the first place! That does mean I have to find a better name for it, though.

-km

I plan to implement Method X when I get a moment. I'm not completely skeptical about its monotonicity since it doesn't seem like there's an obvious argument why it shouldn't be monotone.

For Landau, I use some code like this, which I base on the explanation on Wikipedia:

let landau = [];
for(x in candidates) {
let i_am_covered = false;
for(z in candidates) {
if( x != z ) { // X can't cover themselves
let found_y = false;
for(y in candidates) {
// Note that beats_or_ties should evaluate as true if the two operands are the same candidate
if( x beats_or_ties y && y beats_or_ties z ) {
// alternative to the above line which should be right:
// if( not( y beats x || z beats y ) ) {
found_y = true; // found a counterexample to Z covering X
break; // cease checking for Ys for this Z
} //if x...
} //for y
if( not found_y ) {
i_am_covered = true; // Z evidently covers X
break; // cease checking for Zs for this X
} // if not found_y
} // if x!=z
} // for z
if( not i_am_covered ) landau.append( x );
} // for x
return landau;

Kevin
(end)

Le mercredi 2 août 2023 à 09:54:45 UTC−5, Forest Simmons forest.simmons21@gmail.com a écrit :
On Wed, Aug 2, 2023, 4:15 AM Kristofer Munsterhjelm km_elmet@t-online.de wrote:

Let M be the matrix whose (j,k) element is one (else zero) if candidate j defeats candidate k.

Then candidate j is uncovered iff the j_th row of (I+M)^2 is devoid of zeros  ... because the (j,k) element of this matrix is the number of distinct short beatpaths (i.e. of length 0,1, or 2) from candidate j to candidate k.