Dick Burkhart dickburkhart at comcast.net
Sat Feb 8 22:43:06 PST 2014

```Your method of clustering is interesting but I am computing much more
general clusters. These may be formed around slates of 2 or more candidates,
especially for larger groups that may elect 2 or more candidates. Also I am
using methods of continuous mathematics as well as discrete. For example, I
represent a group by a mean vector (of rankings or ratings) and its
corresponding sigma vector (or, more generally, its covariance matrix). I
measure similarity by ordinary correlation (dot product). This means that a
given ballot (or a consolidation of ballots with the same top rankings) may
be correlated to more than one cluster, hence have partial membership in
more than one cluster, with the "fuzzy set" restriction that the sum of the
memberships of a given ballot over all the clusters may not exceed 1.
Ballots are put partially or fully in a group of "independent voters" when
they are not fully assigned to the clusters.

These clusters will themselves often overlap to some degree and there must
be a correlation parameter which either keeps them separate or allows them
to merge. This happens during the convergence of the clusters (a non-linear
iterative process) since whenever new cluster mean and sigma vectors are
computed (simultaneously over all clusters), then the membership of the
ballots in the clusters changes, hence the next mean and sigma vectors as
well.

This approach helps to reveal the complexity (as in chaos theory, sensitive
dependence, etc.) that is part of all voting methods but which normally only
reveals itself in the form of anomalous results or through careful analysis
of special cases. I can play with certain parameters to see whether the
resulting groups are stable or if there are alternative groupings which are
almost as good. As such I am not focused on the long lists of voting
criteria that experts use, but on overall statistical performance,
acknowledging that it will always be the case that occasionally even very
small changes in a parameter or in the set of ballots will cause
significantly different results. Rather my goal is reduce the frequency and
severity of such anomalous results.

Dick Burkhart
4802 S Othello St,  Seattle, WA  98118
206-721-5672 (home)  206-851-0027 (cell)
dickburkhart at comcast.net

-----Original Message-----
From: Kristofer Munsterhjelm [mailto:km_elmet at t-online.de]
Sent: February 08, 2014 2:01 AM
To: Dick Burkhart
Cc: jgilmour at globalnet.co.uk; stv-comparison at googlegroups.com;
election-methods at lists.electorama.com; 'Þorkell Helgason'; 'Þorkell
Helgason'

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 instead one top candidate.

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 benefits from your vote.

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.
-------------- next part --------------
A non-text attachment was scrubbed...
Name: winmail.dat
Type: application/ms-tnef
Size: 6026 bytes
Desc: not available
URL: <http://lists.electorama.com/pipermail/election-methods-electorama.com/attachments/20140208/7fa06b2f/attachment-0004.bin>
```