[EM] Soliciting feedback for a modification of Allocated Score

[Kristofer Munsterhjelm]

On 12.04.2022 17:28, Andy Dienes wrote:
> Hi Kristofer,
> 
>> You'll get quota proportionality anyway, as long as you reweight
>> everybody who contributes to getting a candidate elected, in such a way
>> that their total weight afterwards is equal to the surplus.
> 
> As long as voters vote along party-lists, this is true, and most such
> "quota spending" methods degenerate to Hamilton. However for an
> arbitrary approval profile only Proportional Justified Representation
> (PJR) is guaranteed. PJR is quite weak and there are often many
> committees satisfying it for a given ballot set, and some of these
> committees are substantially less fair / quality than others. I have
> found theoretically and empirically that the way the support is spent
> can matter a lot in terms of outcome quality.

Yes, I should've qualified what I said by that if either there are few
seats or few ranks/grade levels, then the proportionality criterion is
very weak. In the single-winner case, the Droop proportionality
criterion is mutual majority and Hare proportionality is merely unanimity.

I'm not familiar with the justified representation criteria, but I
imagine the looseness of PJR is for a similar reason.

Do there exist Approval proportionality criteria that imply that the
method's party list behavior must be equivalent to that of a divisor method?

> I agree that the modification of AS might reduce free-riding hopefully!
> Although I find it somewhat hard to analyze strategic incentives
> generally when not isolated to single examples.
> 
>> which maximally delays the decision of just what ballot weights to
>> attenuate.
> 
> Looks quite interesting, and related to the Maximin Support method
> [1609.05370] which I already have implemented, so I can compare when I
> get some more time in a few weeks.

Without having investigated it in detail, I'd say that it makes sense
for a maximin method to resist vote management. Schulze used something
similar for Schulze STV.

> I would be worried that this is not always resolute, in that if many
> voters truncate their ballots not every candidate can achieve a
> quota. Maybe it can be rephrased to be more immediately similar to
> Maximin Support, this could be done just by> changing the objective
> to
> 
> maximize (over support distributions): minimum_{1 <= j <= n+1}: sum over all voters v: support[v][j]

I see your point. While every otherwise unranked candidate is considered
after all ranked candidates have been considered, this in effect
produces a very large tie.

For instance, consider this election that really exercises that part of
the method:

1: A
2: B
...
29: Z

two to elect. The Droop quota is 435/2 = 217.5.

With r=1, nobody can exceed the quota. With r=2, the method effectively
sees:

1: A>B=C=D=...=Z
2: B>A=C=D=...=Z
...
29: Z>A=B=C=...=Y

Now there's a tie because support[v][1] >= 0 for all candidates since
they're all ranked at or higher than second rank, so every candidate has
the same maximum. The method doesn't explain what to do at that point,
so you're right.

What's happening is comparable to an ordinary BTV or Bucklin case where
nobody has a quota (or majority) until suddenly everybody has a quota
(or majority).

Unfortunately, the maximin criterion won't work because the second index
to the support matrix is the jth candidate to be elected, i.e. it's
related to rank but isn't the same thing. When no candidate has been
elected (like the example above), j=1 is all we have, so the maximin
criterion is the same as the current one.

Ordinary Bucklin methods tend to solve it by looking at prior ranks.
That makes sense here because we would want Y and Z to be elected like
in SNTV. However, there is a problem. Suppose we break the tie by
whoever attained the highest support in the last round. Then it's still
possible to contrive an example where everybody has the same support in
the last round (although doing so is very difficult).

The pragmatic approach may simply be to record the maxima for the last
round and then break any further ties at random. An alternative would be
to use a QLTD approach, but it could become quite hard to understand.
Something like this (rough sketching):

minimize: lambda

...

Criterion 2:
	for i = 1... n+1:
		support[v][i] >= 0  if voter v ranks c_i at or higher than rank r
		support[v][i] <= (v's initial weight * lambda) if v ranks c_i at or
lower than rank q

In the case of a tie, run this program with q=r, for all tied candidates
and elect the one with the lowest lambda. If there's still a tie, take
those tied candidates and run again with q=r-1 and so on.

There's no really good solution.

-km