🔢 mathematics

Counting Votes with Multisets

This paper demonstrates how the categorical properties of multisets—specifically their structure as a free commutative monoid, functor, and monad—can be effectively applied to derive and express outcomes in various voting systems, including instant-runoff, De Borda, and single transferrable vote.

Original authors: Bart Jacobs, Michael Johnson, Richard Buckland

Published 2026-06-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Bart Jacobs, Michael Johnson, Richard Buckland

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are running a vote, but instead of counting paper ballots one by one, you are managing a giant bag of colored marbles. This is the core idea of the paper: Multisets.

Here is a simple breakdown of what the authors, Bart Jacobs, Michael Johnson, and Richard Buckland, are proposing, using everyday analogies.

1. The Magic Bag (What is a Multiset?)

Usually, in math, a "set" is like a list of unique items. If you have a set of fruits, you can have an apple and a banana, but you can't have "two apples" in the set definition; it's just "apples."

A Multiset is like a bag of marbles.

If you put 4 red marbles, 3 blue marbles, and 2 green marbles in a bag, the order doesn't matter.
What matters is the count.
The authors write this as: 4|R⟩ + 3|B⟩ + 2|G⟩.
In an election, this bag represents the votes. It doesn't matter who voted or when they voted; it only matters that there are 4 votes for Red, 3 for Blue, and 2 for Green.

Why is this good?
If you keep votes in a list (like a spreadsheet), the order of the list might accidentally reveal who voted for whom. But if you just dump everything into a "multiset bag," the order disappears. You get a clean, anonymous count that is impossible to trace back to individuals.

2. The Three Voting Games

The paper shows how this "bag of marbles" approach makes three complex voting systems much easier to understand and calculate. They use some fancy math terms (like "functors" and "monads"), but think of them as rules for moving marbles around.

Game A: Instant-Runoff Voting (The "Elimination" Game)

How it works: Voters rank candidates (1st, 2nd, 3rd). If no one gets 50% of the votes, the person with the fewest votes is kicked out. Their votes are then given to the voters' second choice.
The Multiset Trick: Imagine your bag of ballots is a stack of lists.
1. You look at the top of every list (the 1st choice) and count the marbles.
2. You find the loser (Candidate C).
3. You use a "magic eraser" (called a functor in the paper) to delete Candidate C from every single list in the bag.
4. Now, the 2nd choices become the new 1st choices. You count the bag again.
5. You repeat this until someone has a majority.
The Benefit: Instead of manually crossing out names on thousands of papers, you just apply the "delete" rule to the whole bag at once.

Game B: De Borda Count (The "Weighted Points" Game)

How it works: Voters rank candidates. The 1st choice gets 4 points, 2nd gets 3, 3rd gets 2, etc. Everyone's points are added up.
The Multiset Trick:
1. Instead of just counting votes, you turn every single ballot into a mini-bag of weighted marbles. A ballot saying "A, B, C, D" becomes 4|A⟩ + 3|B⟩ + 2|C⟩ + 1|D⟩.
2. You dump all these mini-bags into one giant super-bag.
3. You use a "flattening" tool (called a monad) to smash all the layers together.
4. The result is one big count of total points for each candidate.
The Benefit: It turns a complex math problem into a simple "add everything up" operation.

Game C: Single Transferable Vote (The "Surplus Sharing" Game)

How it works: This is used when electing multiple people (like a city council). There is a "quota" (a minimum number of votes needed to win). If a candidate gets way more votes than needed, the extra votes shouldn't be wasted; they should be transferred to the voters' next choice.
The Multiset Trick:
1. Imagine a candidate wins with 93 votes, but the quota is only 63. They have 30 "surplus" votes.
2. Instead of picking 30 random papers to transfer (which is unfair), the authors suggest a mathematical trick: Devalue the votes.
3. You take all 93 votes for that winner and shrink them down by a specific fraction (like shrinking a photo).
4. You then "delete" the winner from the lists and transfer these "shrunken" votes to the next candidates.
5. This allows the math to handle fractions of votes perfectly, ensuring no votes are wasted or counted twice.

3. Why Does This Matter?

The authors aren't trying to invent a new type of math; they are showing that old math (Category Theory) is the perfect tool for modern voting.

Transparency: Because multisets ignore the order of votes, the counting process is mathematically guaranteed to be anonymous.
Simplicity: Complex rules (like deleting losers or splitting surplus votes) become simple operations on a bag of marbles.
Correctness: If you write a computer program to count votes using these "bag" rules, it is much harder to make a mistake than if you try to sort through piles of paper.

In a nutshell: The paper argues that if we stop thinking of votes as a messy pile of paper and start thinking of them as a bag of colored marbles, we can use simple, powerful math rules to count them fairly, quickly, and without error.

Technical Summary: Counting Votes with Multisets

Problem Statement
The paper addresses the challenge of describing, explaining, and implementing vote counting algorithms for complex election systems, particularly those involving preferential voting (preferendums) and multiple weighted options. While simple elections (e.g., two candidates, single vote) can be described via lists or simple counts, mechanisms such as Instant-Runoff Voting (IRV), De Borda counts, and Single Transferable Vote (STV) involve transferring surplus votes, eliminating candidates, and re-weighting preferences. The authors argue that standard datatypes like lists are suboptimal for these tasks because they retain order (which is irrelevant to the outcome) and can leak information regarding the sequence of voting, potentially compromising confidentiality. Furthermore, implementing these algorithms with lists often leads to complex, ad-hoc code that is difficult to verify for correctness and transparency.

Methodology
The paper proposes modeling election outcomes and vote counting processes using multisets (sets where elements may occur multiple times) rather than lists. The authors employ elementary techniques from category theory to formalize the operations on these multisets. The core methodology involves:

Datatype Selection: Representing a collection of votes as a multiset $N(X)$ (or $M(X)$ for fractional votes), where elements are candidates and multiplicities are vote counts. This abstracts away the order of votes.
Categorical Structures: The authors utilize three specific categorical properties of multisets to derive and express voting algorithms:
- Commutative Monoid: Multisets form a free commutative monoid, allowing for the addition of vote counts (union of urns) where order is irrelevant.
- Functoriality: The multiset construction $N$ acts as a functor. This allows functions defined on candidates (e.g., "head of list" or "delete candidate") to be lifted to functions on multisets of lists. This property is used to aggregate first preferences and to redistribute votes when a candidate is eliminated.
- Monad Structure: Multisets form a monad with unit (creating a singleton multiset) and flatten (collapsing a multiset of multisets). This structure is used to handle weighted counts where a single vote (a list of preferences) is decomposed into weighted contributions to multiple candidates.

Key Contributions and Results
The paper demonstrates the application of these categorical structures through three specific voting mechanisms, using small-scale examples (verified via Python scripts from the EfProb library) to illustrate the abstraction:

Instant-Runoff Voting (IRV):
- Mechanism: Candidates with the fewest first-preference votes are eliminated iteratively, and their votes are transferred to the next preference.
- Application: The authors use the functoriality of multisets. The head function (selecting the first preference) and the delete function (removing an eliminated candidate) are lifted to operate on the multiset of preference lists. This allows the aggregation of first preferences and the subsequent redistribution of votes to be expressed as simple functional compositions ( $N(\text{hd})$ and $N(\text{del } c)$ ), avoiding complex iterative list processing.
De Borda Count:
- Mechanism: Voters rank candidates, and points are assigned based on rank (e.g., 1st place gets $n$ points, 2nd gets $n-1$ , etc.).
- Application: The monad structure is utilized. Each preference list is mapped to a multiset of weighted candidates (via unit and point assignment). The collection of all such weighted multisets forms a multiset of multisets. The flatten operation then collapses this structure into a single multiset of total scores, efficiently summing the weighted contributions.
Single Transferable Vote (STV):
- Mechanism: Used for multi-member electorates. Candidates exceeding a quota (Droop quota) are elected, and their surplus votes are transferred to the next preference.
- Application: The authors extend the datatype to fractional multisets ( $M(X)$ ) to handle the "transfer value" (a fraction of a vote). They utilize the monoid structure for subtraction (devaluing votes used to elect a candidate) and the functoriality for redistribution. The process is modeled as an iterative subtraction of the elected candidate's quota-weighted votes from the total multiset, followed by the removal of the elected candidate and the transfer of the remaining fractional weights to the next preference.

Significance and Claims
The paper modestly claims that its primary contribution is not in deep category theory, but in the recognition and exploitation of existing categorical structures (functors, monads, monoids) within the domain of voting systems. The authors argue that:

Abstraction: Describing these algorithms in terms of multisets makes them "abstract," allowing complex mechanisms to be described in a few lines of mathematical notation.
Correctness and Transparency: The multiset approach inherently ensures stability under the permutation of votes (order independence), a fundamental requirement for fair counting. It separates the logic of counting from the physical or sequential representation of ballots.
Implementation: The abstraction facilitates the creation of provably correct implementations in functional programming languages (e.g., Haskell) that support multisets.
Accessibility: The paper aims to make these categorical techniques accessible to non-experts, demonstrating that they are practical tools for ensuring transparency and accuracy in election outcomes, rather than purely theoretical constructs.

The paper concludes that while simplifying assumptions were made (e.g., uniform list lengths), the multiset approach offers a robust framework for future reference implementations and the analysis of election algorithms, moving beyond the historical reliance on sorting physical ballot papers.