# [EM] Question about a criterion for ballot counting

Jan Kok jan.kok.5y at gmail.com
Tue Jun 6 00:14:49 PDT 2006

```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

```