Kristofer Munsterhjelm km_elmet at t-online.de
Sat Feb 8 02:01:20 PST 2014

```On 02/08/2014 04:13 AM, Dick Burkhart wrote:
> This is article concerns a rather narrow and somewhat artificial concept of
> proportional representation. We usually think of proportional representation
> as saying that the number of representatives for a group of voters should be
> proportional to the size of the group. But here it is assumed that every
> voter is assigned to one and only one representative and the goal is to
> minimize, in some numerical sense, the mismatches voters’ desired
> representative and their assigned one (which is their desired one if that
> person is elected but is otherwise a second or lower place choice, assuming
> a preferential ballot).
>
>
> The “group” enters only indirectly, as the group of voters whose top
> preference is a particular candidate, so the number of groups = the number
> of candidates.  In real life, of course, voters will often for a party or
> other interest group, which in many cases will promote a slate of candidates

It seems to me that this process is like Condorcet (or Borda) in that it
doesn't explicitly care about groups, but it handles groups anyway
because, if a voter ranks all group members ahead of non-group members,
then the method will prefer those group members to non-group members.

Since the paper explicitly mentions that Monroe uses Borda for its
misrepresentation function (p. 3, marked as 477), I'm going to use a
Borda example. Consider a Borda election where someone votes a ballot like:

A1 > A2 > A3 > A4 > B > C > D.

Here, A* is obviously a group, but the system doesn't register them
explicitly as a group. To the system, they're no different from
candidates B, C, and D. Instead, the group members are more likely to be
elected than the non-group members simply because they're ranked ahead
of them. This gives the group members a higher score than the non-group
members.

Monroe and Courant's systems seem to be similar. It's true that the
method picks a designated representative for each group. But if you rank
group members ahead of non-group members, then it'll try to put you in
one of the group members' clusters before it puts you in a non-group
cluster, because putting you in a non-group-member's cluster will have a
greater effect on the misrepresentation function. Hence, the group

The advantage of doing it in this way is that the method is flexible:
sice it doesn't have a concept of "group" vs "not group", it can handle
edge cases more smoothly. And you'd want a method to be smooth: abrupt
changes (say, between "this looks enough like a group to be treated as
one" and "this doesn't look enough like a group to be treated as one")
often show up as criterion violations.

> I was not surprised that in a number of cases (using actual votes from
> Scotland and Ireland) the best set of elected according to my clustering
> algorithm did not match the best sets according to the above 3 measures,
> which also differed among themselves. In fact the measure of
> misrepresentation that I used was least able to distinguish among different
> but reasonably good sets of elected, with the “at least one elected” measure
> being the best of the 3. My clustering algorithm first does a careful
> pattern recognition to identify groups (or clusters) of voters who rank (or
> rate) the candidates in similar ways, and only then matches candidates to
> these groups according to group size. So the simplistic top choice candidate
> grouping of this paper is in fact often not as proportional as it could be
> in the real world of politics.

It's also possible to directly take deeper preferences into account
without needing to identify groups or non-groups. For instance, I once
constructed a PR method based on Kemeny clustering. To elect k
candidates, it would go through every way of assigning different full
orderings (with different candidates ranked on top) to k clusters. Each
cluster's misrepresentation function is the sum of the Kendall-tau
distance between that cluster's voters and the assigned ordering, and I
used mixed integer programming to assign voters to equal-size clusters
in such a way as to minimize the sum of misrepresentation. Finally, it
would elect the top candidate from each cluster's designated ranking.

That method did consider the full rankings of the voters. However, it
was very slow and also very nonmonotone. While I think that the former
can be fixed by using a more clever MIP formulation of another Condorcet
method (Young's method), the latter seems harder to fix without being a
quite good mathematician. And I wasn't, so I didn't do anything more
with it. But it *is* possible to be more direct about the deeper
preferences, if so desired.

```