Vote page

Results page

Just include something like <iframe style="width: 100%; height: 400px;" src="https://modernballots.com/public/zombies/vote/"></iframe>

The election occurs, the results come in and a compromise 50/50 film is declared the winner. Well, by some peculiarity of preferences, this just doesn’t sit well with the comedy-lovers, so come movie night, most of them don’t show up.

Should the votes of those that didn’t even show up count? If we reuse the ballots of those that show up, we’re likely to reach a far more tragedy-heavy winner. Further, if this movie night is held monthly, do we favourably weigh the votes of those that didn’t show up?

It’s surprisingly easy and wholly filling.

1. Heat the hotpot up in the oven at roughly 400°F for 5 minutes or so. Enough to get the whole thing nice and piping.
2. Pull it out and put it on your stove on high with some sesame oil and potato for a minute.
3. Add about half a cup of hot water, a bundle of yuba, and spices to taste (e.g. a cube of Golden Curry Sauce Mix).
4. Let that boil off before adding a couple cups of cooked rice, one shredded carrot, a couple inches of chopped ginger, some snow peas, and some pre-steamed gyoza.
5. Turn the element down as low as it can go, cover with the lid and let it sit for 10 minutes or so to brown the bottom.

Instead, consider something akin to a federal MMP. If your chosen candidate doesn’t win, your vote is transferred to the party leader of your choice: a two-part ballot. In our current system, you aren’t represented unless you voted for the winning candidate of your riding.

To estimate the outcome of this new system, let’s assume that vast majority voting for a candidate support their party too. Each geographic seat would be the same as it is now. For example, Vancouver Centre’s Hedy Fry still represents the riding, but only at a power of 18k. The remaining 41k ballots are transferred to the appropriate parties.

Nationally, 2.17m ballots would be transferred to the Liberals from voters in ridings where they didn’t win, 2.13m to the NDP, 1.44m to the Conservatives, 818k to the Bloc, and 539k to the Green Party. The end result has the geographic representatives holding 7.42m geographically proportional votes and the party representatives holding 7.10m, resulting in a party proportional parliament.

• Elections result data
• Script used to calculate these results

Gerrymandering in this system would be moot, although I gather voting fraud might rise. There’s also the question of who would hold the party seats. The party leaders seems like the most direct answer, but I’m not sure how I feel about any one representative wielding upwards to 15% of the total voting power in parliament.

Using the CBC vote compass, we can approximate how these voters might have ranked each candidate if given the option for a more expressive ballot.

Given these preferences (which I admit are a wild estimate; people vote tactically concealing their true preferences), the Condorcet winner would be the Liberal Party’s candidate. Indeed, the national breakdown would have produced results like so (full estimate attached):

For the curious, the code used to generate the above is attached.

• Elections Canada preliminary data
• Sample source code
• Python vote core

from django.conf import settings
from git import Repo
import hashlib, os
git_head = Repo(settings.PROJECT_DIR).heads[0].commit.hexsha
salted_git_head = hashlib.sha512("".join([
    git_head,
    os.getlogin(),
    "".join(os.uname()),
])).hexdigest()[0:6]
def git_head(request):
    return {
        "GIT_HEAD": git_head,
        "SALTED_GIT_HEAD": salted_git_head,
        "SALTED_GIT_QS": "v=%s" % salted_git_head,
    }

Let’s say you run a summer camp. At the start of the summer, 100 campers arrive and learn that you offer 5 unique courses. These courses can’t have more than 25 campers each. The campers all submit ballots expressing their preferences for the courses. How do we maximize course allocation satisfaction?

The general case

• V voters that each submit a ballot of preferences
• G groups, each with a maximum capacity (e.g. G₁^cap = 25)
• Maximize satisfaction (open to interpretation)

Algorithm sketches

A horrible algorithm

for group-x in groups:
    while group-x has remaining capacity:
        allocate any unallocated voter to group-x

Clearly this isn’t going to cut it. Preferences aren’t being taken into account at all. We’re just dumping voters into groups.

Linear optimization

convert each ballot into an allocation of points where
    all group preferences are in [0, 1]
    sum of group preferences = 1
system satisfaction = sum of voter satisfaction for all voters
linear optimization to maximize system satisfaction

As an illustration of the principle, consider an example with voter V₁ that prefers G₁ and voter V₂ that prefers G₂. Assigning the voters to their preferred groups optimizes the system satisfaction at 2, whereas switching them around produces a system satisfaction of 0. Okay, this is a step forward.

Possible problem case:

5 groups, each with a capacity of 1
voter 1:  0.4  0.2  0.2  0.2  0.0
voter 2:  0.7  0.2  0.0  0.0  0.1
voter 3:  0.0  0.7  0.2  0.0  0.1
voter 4:  0.0  0.0  0.7  0.2  0.1
voter 5:  0.2  0.0  0.0  0.7  0.1
system optimizes with voter 1 in group 5
voter 1 allocated to their least preferred group

This algorithm provides a measure of preference debt that we can use in the iterative versions of this problem. Also, I’m not sure how much of an issue tactical misrepresentation is here.

Additional problems

Consider the additional problem where voters vote once per day for new sets of courses. This can vary on fixed or variable set of voters, on a fixed or variable set of groups. Consider further the constraint where groups have both a minimum and a maximum capacity. Or perhaps where C has preferences for G and G has preferences for C.

I don’t quite have the solutions to any of this just yet, but it’s an interesting problem space. Someone has to have studied this already. Pointers in the right direction?

Dough

• 1¼ cups warm water
• 2 tsp baking yeast
• 3 tbsp sugar
• 3 cups flour
• 1 tsp salt

Spice spread

• ¼ cup margarine
• 1 tsp cinnamon
• ¼ tsp nutmeg

Sugar spread

• 2 tbsp brown sugar
• ¼ cup raisins
• ¼ cut walnuts

Method

1. Make the dough as per usual (combine the water, yeast and sugar; let the mix sit for 10 minutes; mix in the flour and salt; knead for 5 minutes).
2. Roll the dough out as thin as you can without it tearing. Try to aim for aim for a rectangular shape.
3. Mix and smear the spice spread thinly across the entire surface.
4. Sprinkle the sugar spread evenly across all the surface save for one edge (which will become the outer rim).
5. Roll the dough up from the inner rim to outer.
6. Slice the long roll thick disks. About 12-15 rolls should come from this.
7. Cover and let rise for 2 hours before baking at 350°F for 25-30 minutes.
8. Let cool before icing. A mixture of 1 part icing sugar and 1 part Tofutti cream cheese has worked well for me.

Starter mix

• 2 tsp active dry yeast
• ¼ cup warm water
• 1 tsp sugar

Dry base

• 3 cups flour
• 1 tsp salt
• 1 tsp dried oregano
• 1 tsp dried basil
• 1 tsp ground pepper
• 1 tsp ground rosmary
• 1¼ cup warm water

Method

1. Combine the starter mix and let it stand for 10 minutes while the yeast starts doing its thing
2. Sift the dry base together and add it to the starter mix
3. Knead the dough until it’s all well combined and let it sit covered for about an hour
4. Knead the dough again, roll it out and do whatever you’d like with it
5. Bake at about 450°F for 15 minutes (though this guy uses 800° for a little under 2 minutes)