# [EM] Question about a criterion for ballot counting

Alex Small alex_small2002 at yahoo.com
Tue Jun 6 08:05:03 PDT 2006

```Jan-

I imagine something like this:

If (condition A1 and condition A2 and...) OR (condition A3 and condition A4 and...) OR ()...  Then elect A
Else If (condition B1 and condition B2 and...) or (condition B3 and condition B4 and...) or ()... Then elect B

And so forth.  That's how ordinary voting methods work.  For instance, Plurality:

If (A has more votes than B And A has more votes than C) Then Elect A
Else If (B has more votes than A And B has more votes than C) Then Elect B
Else If (C has more votes than A And C has more votes than B) Then Elect C.

For IRV it's a little more complicated:

If (A has a majority) OR (C is eliminated and A beats B pairwise) Then Elect A

And so forth.

For both of those methods, and for any other election method that I can think of, 2 conditions hold:

1)  There is only a finite list of conditions to check, and the same list of conditions can be used for any number of ballots cast.
2)  Each condition involves a linear inequality.  When I say "linear", I mean that it's a linear function of the number of ballots cast of each type.  You don't have to, say, take the square of the number of ballots that list A>B>C and add to it the square of the number of ballots that list A>C>B or whatever.  It's all linear.

I assumed that the method meets these criteria in my work.  They are perfectly reasonable criteria, and any public election proposal would meet these criteria.  However, mathematically you could construct methods that don't meet these criteria.  Since I'm doing a mathematical proof I need to exclude methods that involve squares and cube roots and sines and all sorts of other nonlinear stuff, as well as methods that have an infinite number of conditions or whatever.  I would like to be able to just invoke some criterion that's already established in the literature, rather than spend a few paragraphs of the paper digressing on the importance of a list of linear inequalities.

Consider that I spent a few paragraphs explaining myself in my first post and you weren't entirely sure that you understood me, and now I've spent a few more paragraphs and I'm still not sure if my point is clear.  I don't want to have to do that in a paper.  I want to be able to say "Look, we have a simple list of rules, with 'simple list' defined in the same way that everybody else defines it (see this reference" and then move on.

Can anybody help me out?

Alex

Jan Kok <jan.kok.5y at gmail.com> wrote:
I'm not sure I even understand your question! But it sounds like a
very interesting one!

Are the "list of rules" actually procedures? For example, is "if
[condition] then go to step 3" a valid rule?

Are you allowed to set and change variables, e.g. let i=1, let i=i+1 ?

Are you willing to restrict the number of candidates to some small
number, like 4, in order to avoid the need for looping?

As you may know, and I vaguely remember, a Turing Machine (TM) is a
very simple kind of computer. It has only a small handful of
instructions. And yet a TM can do anything that our most powerful
computers can do (if you don't mind waiting, or the TM runs very
fast). So, if the "language" or the "instruction set" that you use to
build your "lists of rules" is sufficient to emulate a TM, then you
can't prevent anyone from computing arbitrary mathematical functions
like square, sine, etc.

So, it seems you must be careful to not make your language as capable
as a Turing Machine! But then, how can it handle arbitrary numbers of
candidates and ballots?

Perhaps you could provide a limited number of loops in a standard
template, such as:

for c = 1 to number_of_candidates
/* user-supplied instructions allowed here (to initialize candidate
information) */
end for
for b = 1 to number_of_ballots
/* user-supplied instructions allowed here (to initialize ballot
information) */
end for
for c = 1 to number_of_candidates
/* user-supplied instructions allowed here */
for b = 1 to number_of_ballots
/* user-supplied instructions allowed here */
end for
/* user-supplied instructions allowed here */
end for
/* user-supplied instructions allowed here */

Loops and backward jumps would not be allowed in the user-supplied instructions.

My guess is that most voting methods can be described with the above
program template, and some very simple operations such as add a
constant, get the nth element of an array, and get the index in an
array of the nth-largest element.

Am I on the right track?

Cheers,
- Jan

__________________________________________________
Do You Yahoo!?
Tired of spam?  Yahoo! Mail has the best spam protection around
http://mail.yahoo.com
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.electorama.com/pipermail/election-methods-electorama.com/attachments/20060606/88ed6611/attachment-0003.htm>
```