Towards Computing Victory Margins in STV Elections

TL;DR

This paper introduces algorithms to compute bounds on the victory margin in STV elections, aiding election auditing and integrity assessment by estimating how much vote manipulation could change the outcome.

Contribution

It presents the first algorithms for calculating lower and upper bounds on the MOV in STV elections, including exact margins for small instances.

Findings

Algorithms can compute exact margins in small elections.

Bounds provide insight into election robustness.

Method enhances election auditing processes.

Abstract

The Single Transferable Vote (STV) is a system of preferential voting employed in multi-seat elections. Each vote cast by a voter is a (potentially partial) ranking over a set of candidates. No techniques currently exist for computing the margin of victory (MOV) in STV elections. The MOV is the smallest number of vote manipulations (changes, additions, and deletions) required to bring about a change in the set of elected candidates. Knowledge of the MOV of an election gives greater insight into both how much time and money should be spent on the auditing of the election, and whether uncovered mistakes (such as ballot box losses) throw the election result into doubt---requiring a costly repeat election---or can be safely ignored. In this paper, we present algorithms for computing lower and upper bounds on the MOV in STV elections. In small instances, these algorithms are able to compute exact margins.

Tables

Table 1. (a)

Ranking	Count
[$c_2$, $c_3$]	4
[$c_1$]	20
[$c_3$, $c_4$]	9
[$c_2$, $c_3$, $c_4$]	6
[$c_4$, $c_1$, $c_2$]	15
[$c_1$, $c_3$]	6

Table 2. (a)

Ranking	Count
[$c_2$, $c_3$]	4
[$c_1$]	20
[$c_3$, $c_4$]	9
[$c_2$, $c_3$, $c_4$]	6
[$c_4$, $c_1$, $c_2$]	15
[$c_1$, $c_3$]	6

Table 3. (b)

Seats: 2
Quota: 21
Candidate	Round 1	Round 2	Round 3
	$c_1$ elected	$c_2$ eliminated	$c_3$ elected
	${\tau }_1$ $=$ $0.83$
$c_1$	26	—	—
$c_2$	10	10	—
$c_3$	9	14	24
$c_4$	15	15	15

Table 4. (a)

Ranking	Count
[$c_1$, $c_2$, $c_3$]	5
[$c_1$]	18
[$c_4$, $c_3$]	10
[$c_3$, $c_2$, $c_4$]	5
[$c_2$, $c_4$, $c_3$]	17
[$c_1$, $c_4$, $c_2$, $c_3$]	8

Table 5. (a)

Ranking	Count
[$c_1$, $c_2$, $c_3$]	5
[$c_1$]	18
[$c_4$, $c_3$]	10
[$c_3$, $c_2$, $c_4$]	5
[$c_2$, $c_4$, $c_3$]	17
[$c_1$, $c_4$, $c_2$, $c_3$]	8

Table 6. (b)

Seats: 2
Quota: 22
Candidate	Round 1	Round 2	Round 3
	$c_1$ elected	$c_3$ eliminated	$c_2$ elected
	${\tau }_1$ $=$ $0.69$
$c_1$	31	—	—
$c_2$	17	20.46	25.46
$c_3$	5	5	—
$c_4$	10	15.54	15.54

$s,𝐒$	A signature $s\in 𝐒$ is a partial or total ranking over the candidates in $𝒞$; $𝐒$ is the set of all possible partial or total rankings over $𝒞$ (including those that do not appear on a vote in $ℬ$).
$ℛ$	The set of rounds of counting in the election—in each round a candidate is either elected to a seat or eliminated.
${𝒫}_{ij}$	The subset of vote signatures that could possibly be in the tally of candidate $i\in 𝒞$ at the start of round $j$ (this can be inferred on the basis of the order of candidates in $\pi$).
$\pi \left[j\right]$	The candidate that is elected or eliminated in round $j$ (according to $\pi$).
${ℬ}_{sij}$	The set of candidates that appear before candidate $i$ in the preference ordering of signature $s\in 𝐒$ that are still standing (have not been elected or eliminated) at the end of round $j$.
${𝒮}_j$	The set of candidates still standing at the start of round $j$.
${\pi }^{+}$	The subset of candidates in $𝒞$ that are elected to a seat according to $\pi$.
${\pi }^{-}$	The subset of candidates in $𝒞$ that are eliminated according to $\pi$.

$N_s$	Number of votes with signature $s\in 𝐒$ cast in election $ℰ$ (i.e., the number of votes in $ℬ$ whose ranking matches signature $s$).
$UB$	Known upper bound on the number of vote manipulations required to realise $\pi$ (such as the winner elimination upper bound of Figure 2 or the Simple-STV upper bound of Section 5).

$p_s$	Integer number of votes in $ℬ$ that are modified so that their new signature is $s\in 𝐒$.
$m_s$	Integer number of votes whose signature in $ℬ$ (the original profile) is $s\in 𝐒$, but are modified to something other than $s$ in the new profile.
$y_s$	Integer number of votes with signature $s\in 𝐒$ in the new election profile.
${\tau }_j$	Transfer value of votes being redistributed from an elected candidate in round $j$.
${\rho }_j$	Number of votes eligible for transfer, from the candidate elected to a seat in round $j$, to candidates that are still standing at the end of round $j$.
$q_{ij}$	Binary variable with a value of 1 if the tally of candidate $i$ exceeds or equals the quota at the start of round $j$, and 0 otherwise.
$v_{ij}$	Floating point number of votes in the tally of candidate $i$ at the start of round $j$.
$y_{ijs}$	Floating point number of votes with signature $s\in 𝐒$ in the tally of candidate $i$ at the start of round $j$.
$d_{ijs}$	Floating point number of votes with signature $s\in 𝐒$ transferred to candidate $i$ from the candidate elected or eliminated in round $j$.

Table 10. (a)

Candidate	Round 1	Round 2	Round 3
$c_1$	[$c_1$], [$c_1,$ $c_3$]	[$c_1$], [$c_1,$ $c_3$]	—
$c_2$	[$c_2,$ $c_3$], [$c_2,$ $c_3,$ $c_4$]	[$c_2,$ $c_3$], [$c_2,$ $c_3,$ $c_4$]	[$c_2,$ $c_3$], [$c_2,$ $c_3,$ $c_4$]
$c_3$	[$c_3,$ $c_4$]	—	—
$c_4$	[$c_4,$ $c_1,$ $c_2$]	[$c_4,$ $c_1,$ $c_2$], [$c_3,$ $c_4$]	[$c_4,$ $c_1,$ $c_2$], [$c_3,$ $c_4$]

Table 11. (a)

Candidate	Round 1	Round 2	Round 3
$c_1$	[$c_1$], [$c_1,$ $c_3$]	[$c_1$], [$c_1,$ $c_3$]	—
$c_2$	[$c_2,$ $c_3$], [$c_2,$ $c_3,$ $c_4$]	[$c_2,$ $c_3$], [$c_2,$ $c_3,$ $c_4$]	[$c_2,$ $c_3$], [$c_2,$ $c_3,$ $c_4$]
$c_3$	[$c_3,$ $c_4$]	—	—
$c_4$	[$c_4,$ $c_1,$ $c_2$]	[$c_4,$ $c_1,$ $c_2$], [$c_3,$ $c_4$]	[$c_4,$ $c_1,$ $c_2$], [$c_3,$ $c_4$]

Table 12. (b)

Candidate	Round 1	Round 2	Round 3
$c_1$	26	26	—
$c_2$	10	10	10
$c_3$	9	—	—
$c_4$	15	24	24

$[(c_1,1),(c_2,0)]$	Lower bound of 0
$[(c_1,1),(c_2,1)]$	Lower bound of 12
$[(c_1,1),(c_3,0)]$	Lower bound of 2
$[(c_1,1),(c_3,1)]$	Invalid as the original winners $c_1$ and $c_3$ are both elected
$[(c_1,1),(c_4,0)]$	Lower bound of 3
$[(c_1,1),(c_4,1)]$	Lower bound of 7

$[(c_1,1),(c_2,0),(c_3,0),(c_4,1)]$	DistanceToSTV evaluation of 3
$[(c_1,1),(c_2,0),(c_3,1),(c_4,0)]$	Invalid as original winners $c_1$ and $c_3$ are elected
$[(c_1,1),(c_2,0),(c_4,0),(c_3,1)]$	Invalid as original winners $c_1$ and $c_3$ are elected
$[(c_1,1),(c_2,0),(c_4,1),(c_3,0)]$	DistanceToSTV evaluation of 6

Table 15. Table 4 : Application of margin-stv to 16 US IRV elections re-imagined as STV elections with 2 seats, reporting: the number of candidates ( | 𝒞 | 𝒞 |\mathcal{C}| ); best upper bound on the MOV; computed MOV (or bounds on the MOV); number of MINLPs solved; and algorithm runtime (in seconds) ( ∞ \infty represents a time out of 12 hours) without and with the use of the lower bounding rule of Sec. 7.1 . Best results for bounds are bolded.

			margin-stv			margin-stv with LB of Sec 7.1
#	$\left|𝒞\right|$	Best UB	MOV	MINLPs	Time	MOV	MINLPs	Time
				solved	(s)		solved	(s)
1	4	38,199	30,654 – 37,908	54	2,528	30,654 – 37,908	35	2,421
2	4	5,683	2,725 – 2,726	17	900	2,725 – 2,726	7	139
3	4	6,530	6,359 – 6,360	25	464	6,359 – 6,360	19	649
4	4	2,527	63	18	171	63	14	169
5	4	653	59	17	20	59	11	19
6	4	763	375	23	708	375	13	1,086
7	5	7,500	7,499 – 7,500	48	213	7,499 – 7,500	30	211
8	5	1,079	628 – 629	45	2,972	628 – 629	30	2,972
9	5	1,425	659 – 660	38	2,331	659 – 660	26	2,318
10	5	422	164 – 165	42	565	164 – 165	22	459
11	7	1,719	441	58	1	441	39	1
12	7	2,289	1,326– 1,327	2,247	13,693	1,326 – 1,327	1,006	12,058
13	8	2,857	1,216 – 1,576	—	$\infty$	1,309 – 1,576	—	$\infty$
14	11	1,178	309 – 1,178	—	$\infty$	351 – 1,178	—	$\infty$
15	11	63	4	244	107	4	190	106
16	13	2,188	823 – 2,188	—	$\infty$	0 – 2,188	—	$\infty$

Table 16. Table 5 : Application of relaxed margin-stv (bilinear terms replaced with McCormick ( 1976 ) inequalities, without and with the lower bounding rule of Sec. 7.1 ) to the STV elections of Table 4 , reporting: the number of candidates ( | 𝒞 | 𝒞 |\mathcal{C}| ); the best known bounds on MOV from Table 4 ; lower bound on the MOV computed by margin-stv ; number of MIPs solved; and algorithm runtime (in seconds). Best lower bounds are bolded.

			margin-stv			margin-stv with LB of Sec 7.1
#	$\left|𝒞\right|$	Exact MOV	MOV	MIPs	Time	MOV	MIPs	Time
		Bounds	(LB)	solved	(s)	(LB)	solved	(s)
1	4	30,654 – 37,908	17,662	28	0.8	23,079	11	0.2
2	4	2,725 – 2,726	399	15	0.2	789	5	0.1
3	4	6,359 – 6,360	3245	28	0.4	6356	12	0.1
4	4	63	0	12	0.1	0	8	0.1
5	4	59	0	13	0.1	0	7	0.1
6	4	375	43	19	0.1	46	10	0.1
7	5	7,499 – 7,500	0	23	0.3	0	13	0.2
8	5	628 – 629	218	33	0.3	339	20	0.3
9	5	659 – 660	64	26	0.3	64	17	0.3
10	5	164 – 165	34	25	0.2	91	19	0.4
11	7	441	441	57	0.6	441	38	0.6
12	7	1,326 – 1,327	413	48	0.9	859	166	4
13	8	1,309 – 1,576	289	215	8	289	117	4
14	11	351 – 1,178	0	723	217	0	347	36
15	11	4	4	243	8	4	189	11
16	13	823 – 2,188	0	—	$\infty$	0	21,520	23,243

Table 17. Table 6: Application of piecewise-relaxed margin-stv ( with the lower bounding rule of Sec. 7.1 ) to the STV elections of Table 4 , reporting: the best known bounds MOV from Table 4 ; lower bound on the MOV computed by piecewise-relaxed margin-stv ; number of MIPs solved; and algorithm runtime (in seconds).

		$K=5$			$K=10$
#	Exact MOV	MOV	MIPs	Time	MOV	MIPs	Time
	Bounds	LB	solved	(s)	LB	solved	(s)
1	30,654 – 37,908	28,038	12	1	29,020	12	1
2	2,725 – 2,726	2,265	6	0.5	2,512	6	1
3	6,359 – 6,360	6,356	13	0.4	6,356	17	2
4	63	0	8	0.1	0	8	0.1
5	59	0	7	0.4	10	9	1
6	375	327	10	0.2	337	10	0.6
7	7,499 – 7,500	5,168	14	0.9	6,347	28	4
8	628 – 629	531	24	2	581	25	7
9	659 – 660	558	19	0.9	609	19	3
10	164 – 165	133	19	4	141	19	3
11	441	441	38	0.7	441	38	0.8
12	1,326 – 1,327	1049	486	37	1,211	698	83
13	1,309 – 1,576	1321	538	65	1,431	636	243
14	351 – 1,178	53	84	22	602	3,008	2,900
15	4	4	189	22	4	189	27
16	823 – 2,188	760	7,025	35,583	95	—	$\infty$
		$K=15$			$K=20$
#	Exact MOV	MOV	MIPs	Time	MOV	MIPs	Time
	Bounds	LB	solved	(s)	LB	solved	(s)
1	20,654 – 37,908	29,549	12	3	29,968	12	3
2	2,725 – 2,726	2,582	6	2	2,609	6	1
3	6,359 – 6,360	6,356	17	2	6,356	17	1
4	63	0	11	0.4	0	11	1
5	59	28	9	1	35	9	1
6	375	351	10	1	358	10	2
7	7,499 – 7,500	6,721	29	3	6,923	29	4
8	628 – 629	598	25	10	606	25	12
9	659 – 660	623	19	5	638	20	4
10	164 – 165	147	19	6	155	19	6
11	441	441	38	0.6	441	38	1
12	1,326 – 1,327	1,221	700	105	1,257	758	185
13	1,309 – 1,576	1,468	747	452	1,486	754	638
14	351 – 1,178	785	10,511	15,732	878	13,786	28,909
15	4	4	189	33	4	189	39
16	823 – 2,188	17	—	$\infty$	0	—	$\infty$

Table 18. Table 7 : The winner elimination upper bound, and lower bound on the MOV, computed for 3 STV elections held in the 2002 Irish General Election (for varying values of K 𝐾 K ). The number of seats, candidates, quota, and number of votes cast in each election is reported, alongside the runtime (in seconds) of margin-stv (– indicates that the algorithm reached the 24 hour timeout) and the number of MIPs solved.

Election	Seats	$\left|𝒞\right|$	Quota	Votes	Upper	$K$	Lower	Time (s)	MIPs
				cast	Bound		Bound		Solved
					on MOV		on MOV
Dublin North	4	13	8,789	43,942	211	5	0	46	400
						15	181	2,905	487
						25	185	10,808	276
						35	199	50,994	394
Dublin West	3	9	7,498	29,988	385	5	0	15	143
						15	153	241	147
						25	211	506	153
						35	235	1,628	151
						60	257	3,914	155
						80	267	14,649	161
						100	269	38,660	157
Meath	5	15	10,681	64,081	1,135	5	275	–	1,997
						15	275	72,349	549

Table 19. Table 8 : The best known upper bound, and lower bound on the MOV, computed for the first 11/21 STV elections held in the 2007 Glasgow City Council Election (for varying values of K 𝐾 K ). The number of seats, candidates, quota, and number of votes cast in each election is reported, alongside the runtime (in seconds) of margin-stv (– indicates that the algorithm reached the 24 hour timeout) and the number of MIPs solved.

Election	Seats	$\left|𝒞\right|$	Quota	Votes	MOV	$K$	MOV	Time	MIPs
				cast	Upper		Lower	(s)	Solved
					Bound		Bound
Linn	4	11	1,914	9,567	221	5	94	1,147	1,840
						15	139	–	5,867
Newlands	3	9	2,164	8,654	88	5	47	14	203
						15	76	78	284
						25	81	363	284
Greater Pollock	4	9	1,737	8,682	223	5	125	1,866	1,647
						15	197	38,428	3,349
						25	159*	–	2,304
Craigton	4	10	2,211	11,052	93	5	0	62	174
						15	0	493	175
						25	25	1,176	168
						35	37	11,321	179
						50	43	39,892	188
						80	31*	–	164
Govan	4	11	1,913	9,560	278	5	149	–	10,808
						15	131*	–	5,226
Pollockshields	3	9	2,392	9,567	30	5	0	1	39
						15	0	6	39
						25	2	19	39
						35	4	20	39
						80	4	347	39
						100	6	681	39
Langside	3	8	2,334	9,334	246	5	124	25	224
						15	193	555	545
						25	209	3,350	553
						35	217	7,266	742
						45	221	14,495	746
						55	224	19,341	752
Southside Central	4	9	1,748	8,738	231	5	113	1,306	1,418
						15	187	68,537	2,313
						25	118*	–	1,120
Calton	3	10	1,300	5,199	959	5	215	18,369	39,356
						15	130*	–	20,048
Anderston	4	9	1,381	6,900	106	5	3	57	168
						15	64	5,596	346
						25	85	16,784	407
						35	94	51,571	517
Hillhead	4	10	1,797	8,984	112	5	0	35	271
						15	41	1,621	270
						25	55	8,277	270
						35	58	27,949	265
						45	0*	–	251

Table 20. Table 9 : The best known upper bound, and lower bound on the MOV, computed for the second 10/21 STV elections held in the 2007 Glasgow City Council Election (for varying values of K 𝐾 K ). The number of seats, candidates, quota, and number of votes cast in each election is reported, alongside the runtime (in seconds) of margin-stv (– indicates that the algorithm reached the 24 hour timeout) and the number of MIPs solved.

Election	Seats	$\left|𝒞\right|$	Quota	Votes	MOV	$K$	MOV	Time	MIPs
				cast	Upper		Lower	(s)	Solved
					Bound		Bound
Partick West	4	9	2,549	12,744	194	5	18	22	166
						15	133	728	207
						25	174	6,407	311
						35	187	10,343	354
Garscadden	4	10	2,033	10,160	449	5	197	–	5,080
						15	96*	–	780
Drumchapel	4	10	1,737	8,680	1,325	5	335	19,325	16,257
						15	0*	–	353
Maryhill	4	8	1,981	9,901	292	5	70	140	329
						15	203	11,580	606
						25	226	25,849	776
						35	234	78,380	747
						45	194*	–	482
Canal	4	11	1,725	8,624	148	5	68	487	576
						15	98	9,384	729
						25	108	36,690	852
						35	109	79,946	844
						45	69*	–	300
Springburn	3	10	1,353	5,410	1,014	5	447	22,772	37,236
						15	305*	–	3,979
East Centre	4	13	1,816	9,078	134	5	73	26,753	16,360
						15	71*	–	10,389
Shettleston	4	11	1,761	8,803	355	5	158	–	13,014
						15	145*	–	4,817
Baillieston	4	11	2,076	10,376	108	5	0	457	266
						15	38	2,088	347
						25	46	11,122	345
						35	58	49,942	383
						45	64	74,870	390
						55	8*	–	300
North East	4	10	1,673	8,363	911	5	275	52,653	9,967
						15	60*	–	385

Table 21. Table 10 : The best known upper bound, and lower bound on the MOV, computed for the 2013 and 2016 NT and ACT Federal Senate elections (for varying values of K 𝐾 K ). The number of seats, candidates, quota, and number of votes cast in each election is reported, alongside the runtime (in seconds) of margin-stv (– indicates that the algorithm reached the 24 hour timeout) and the number of MIPs solved.

Election	Seats	$\left|𝒞\right|$	Quota	Votes	Upper	$K$	Lower	Time (s)	MIPs
				cast	Bound		Bound		Solved
					on MOV		on MOV
2013 NT	2	24	34,494	103,479	25,777	5	223	–	561,999
2016 NT	2	19	34,010	102,027	23,373	5	3121	–	219,876
2013 ACT	2	27	82,248	246,742	35,476	5	82	–	112,629
2016 ACT	2	22	84,923	254,767	44,499	5	205	–	86,825

Table 22. Table 11 : Lower bounds on the MOV, computed for the 2013 ACT Federal Senate election, for varying values of K 𝐾 K , under the assumption that the first R = 20 𝑅 20 R=20 rounds of the original count are fixed. For this election, there are: 2 seats; 27 candidates; a quota of 82,248 votes; and an upper bound on the MOV of 35,476 votes.

$K$	Lower Bound	Time (s)	MIPs
	on MOV		Solved
5	5879	117	41
25	5879	4899	111
50	5911	12,386	112
80	5919	18,604	112

Table 23. Table 12 : Name, number of candidates, and number of votes cast, for 16 IRV elections held in the US between 2007 and 2010, reimagined as STV elections with 2 available seats.

#	Election Name	Candidates	Votes Cast
1	Pierce 2008 County Auditor	4	159,987
2	Pierce 2008 City Council	4	43,661
3	San Leandro 2010 Mayor	4	23,494
4	Oakland 2010 D6 City Council	4	14,040
5	Berkeley 2010 D8 City Council	4	5,333
6	Berkeley 2010 D7 City Council	4	4,862
7	Pierce 2008 County Executive	5	312,771
8	Berkeley 2010 D4 City Council	5	5,708
9	Berkeley 2010 D1 City Council	5	6,426
10	Aspen 2009 Mayor	5	2,544
11	Pierce 2008 County Assessor	7	43,661
12	San Leandro 2010 D5 City Council	7	23,494
13	Oakland 2010 D4 City Council	8	23,884
14	Oakland 2010 Mayor	11	122,268
15	Aspen 2009 City Council	11	2,544
16	San Francisco 2007 Mayor	13	149,465

Equations

$$\text{Quota }=\frac{\text{Total number of votes cast}}{\text{Number of seats}+1}+1$$

$$\text{Total value of votes}=\sum _{\text{votes in tally}}\text{Vote value}$$

$$\text{Surplus}=\text{Tally value }-\text{ Quota}$$

$$\tau =\min \left(1,\frac{\text{Surplus of candidate }c}{\text{Total value of }c\text{’s transferable votes}}\right)$$

$$z=\min \sum _{s\in \mathbf{S}}{p}_s$$

$$\sum _{s\in \mathbf{S}}{m}_s$$

$$y_s$$

$$q_{i,j-1}$$

$$v_{ij}$$

$$y_{i1s}$$

$$y_{ijs}$$

$$v_{ij}$$

$$v_{\pi [j],j}$$

$$q_{ij}$$

$$d_{ijs}$$

$${\rho }_j$$

$${\tau }_j{\rho }_j$$

$${\tau }_j$$

$$V_{cj}^{max}$$

$$V_c^{min}$$

$$l_q(c_j,{\pi }^{\prime })$$

$$l_e^1(c_j,{\pi }^{\prime })$$

$$l_e^2(c_j,{\pi }^{\prime })$$

$$lb({\pi }^{\prime })$$

$$z\ge y^{L}x+x^{L}y-x^L{y}^L$$

$$z\ge y^{U}x+x^{U}y-x^U{y}^U$$

$$z\le y^{U}x+x^{L}y-x^L{y}^U$$

$$z\le y^{L}x+x^{U}y-z^U{y}^L$$

$$\sum _{k=1}^K{\lambda }_k=1$$

$$\sum _{k=1}^K{x}_{k-1}{\lambda }_k\le x\le \sum _{k=1}^K{x}_k{\lambda }_k$$

$$y=y^L+\sum _{k=1}^K\delta y_k$$

$$0\le \delta y_k\le (y^U-y^L){\lambda }_k$$

$$z\ge y^{U}x+\sum _{k=1}^K{x}_k\delta y_k-(y^U-y^L)\sum _{k=1}^K{x}_k{\lambda }_k$$

$$x\le y^{U}x+\sum _{k=1}^K{x}_{k-1}\delta y_k-(y^U-y^L)\sum _{k=1}^K{x}_{k-1}{\lambda }_k$$

$$z\le y^{L}x+\sum _{k=1}^K{x}_k\delta y_k$$

$$z\ge y^{L}x+\sum _{k=1}^K$$

Full text

1 Introduction

The Single Transferable Vote (STV) is a system of preferential voting employed in multi-seat elections. It is used to elect candidates to the Australian Senate, in all elections in Malta, and in most elections in the Republic of Ireland (Farrell and McAllister, 2005). No techniques currently exist for computing the smallest number of vote manipulations (changes, additions, and deletions) required to bring about a change in the set of elected candidates—the margin of victory (MOV). The ability to compute this margin has significant value. In the 2013 election of six candidates to Western Australia’s Senate a discrepancy of 1,375 initially verified votes was discovered during a recount. The election result was overturned, and a repeat election held in 2014. If the MOV for the original election was known, the question of whether the loss of these votes may have altered the resulting outcome could have been answered. In this instance, if the MOV was greater than 1,375 votes, the inclusion of these 1,375 lost votes would not have changed the election outcome.

In an STV election, each vote is a (potentially partial) ranking over a set of candidates. For example, in an election with candidates $c_{1},$ $c_{2},$ $c_{3},$ and $c_{4},$ a vote [$c_{2},$ $c_{1},$ $c_{4}$] expresses a first preference for candidate $c_{2}$, a second for $c_{1},$ and a third for $c_{4}$. At the start of the counting process, each vote is initially awarded to its highest ranked candidate. In the above vote, $c_{2}$ is the highest ranked candidate. The votes awarded to each candidate forms their tally. Candidates whose tallies exceed (or reach) a quota, defined in terms of the number of seats to be filled and votes cast in the election, are elected to a seat. As each candidate is elected, their surplus (the number of votes by which their tally exceeds the quota) is computed, and a subset of their votes (with a combined value equal to the surplus) is distributed to their next preferred candidate (in the above vote, the next preferred candidate after $c_{2}$ is $c_{1}$). Where multiple candidates have a quota’s worth of votes in their tally, the candidate with the largest surplus is elected first, and their surplus is distributed. Then, if there are still seats to fill, the candidate with the next largest surplus is elected, and their surplus distributed (and so on). If no remaining candidate has a quota’s worth of votes, and one or more seats remain empty, the candidate with the fewest votes is eliminated and their votes distributed to their next preferred candidates. If the number of candidates remaining (unelected and not yet eliminated) equals the number of seats left to be filled, these candidates are elected and the STV counting process terminates.

Several STV variants exist, differing in the way that surpluses are distributed (Weeks, 2011). Consider a candidate with a tally of 100 votes and a surplus of 40 votes. The Inclusive Gregory Method redistributes all 100 votes, each with an assigned value of 0.4 (each vote is worth 0.4 votes), to their next highest ranked candidate that is ‘still standing’ (has not yet been elected or eliminated) (Miragliotta, 2004). In the STV variant we consider in this paper, candidates whose tallies have reached or exceeded the quota (but have not yet been awarded a seat) receive no further votes from the surplus distributions of other candidates.

Computing the MOV of an STV election is an extremely complex combinatorial optimisation problem. In an election with $n$ candidates, and $k$ available seats, there are ${n}\choose{k}$ possible allocations of candidates to these seats, and $n!$ different orders in which candidates can appear in the elimination and election sequence. Our task is to find an election outcome, out of the n!$${n}\choose{k} possibilities, that differs from the original outcome of the election and that requires the least number of vote manipulations to realise.

We develop, in this paper, an algorithm for computing exact margins of victory in STV elections that use the Inclusive Gregory Method of surplus distribution—arguably the simplest and most straightforward of the existing variants. In Section 2, we step through the counting process that takes place in STV elections, under the Inclusive Gregory Method, in two example STV instances. The algorithm we present in this paper (labelled margin-stv) is an adaptation of existing work for computing margins in Instant Runoff Voting (IRV) elections (Blom et al., 2016). IRV is a single-seat variant of STV and is employed in lower house elections across Australia, in which a single candidate is elected to a single seat. In an IRV election, candidates with the fewest votes are eliminated, and their votes redistributed to later ranked candidates, until a candidate attains a majority of the available votes, and is declared the winner. The computation of exact IRV and STV victory margins is known to be NP-hard (Bartholdi III and Orlin, 1991; Conitzer et al., 2007; Xia, 2012; Rothe and Schend, 2013; Narodytska and Walsh, 2014).

Our margin-stv algorithm represents the outcome of an STV election as a sequence of candidate elections and eliminations (e.g., $c_{4}$ elected, $c_{3}$ eliminated, $c_{2}$ eliminated, $c_{1}$ elected). We present a mixed-integer non-linear program (MINLP) that, given such an outcome, and the set of votes cast in the election, computes the smallest number of vote manipulations required to realise the outcome. A vote manipulation replaces the ranking of a vote (e.g., [$c_{2},$ $c_{1},$ $c_{4}$]) with an alternate ranking (e.g., [$c_{4},$ $c_{3}$]). Consider an election over candidates $\mathcal{C}$, in which candidates $E\subset\mathcal{C}$ are elected to a seat. Our margin-stv algorithm applies branch-and-bound to search the space of alternate election outcomes (in which the set of winning candidates $E^{\prime}$ $\neq$ $E$) for one that requires the least number of vote manipulations to realise. We show that margin-stv is able to compute exact margins in some small STV election instances. We develop a relaxation of this algorithm capable of computing lower bounds on the margin of victory in larger, more realistic STV election instances.

The remainder of this paper is structured as follows. Section 2 describes the STV counting algorithm. Preliminary definitions and concepts required in the explanation of our margin-stv algorithm are presented in Section 3. Related work is discussed in Section 4. Mechanisms for computing simple upper bounds on the degree of manipulation required to alter the outcome of an STV election are presented in Section 5. Section 6 presents our MINLP for computing the smallest degree of manipulation required to realise a specific election outcome (a specific sequence of elections and eliminations). A rule for computing a lower bound on this degree of manipulation is presented in Section 7. Using these upper and lower bounding techniques as building blocks, we present our margin-stv algorithm, and a relaxed variant of this algorithm, in Section 8. We evaluate these algorithms on a range of both small and large STV election instances in Section 9.

2 The Single Transferable Vote (STV)

This section describes the STV vote counting algorithm that we consider in this paper, outlined in Figure 1. We illustrate this algorithm in the example election shown in Table 1. In Step 1 of the counting algorithm the quota of the election is calculated, according to Equation 1. This is known as the Droop quota, and represents a threshold that each candidate must reach before they are elected to a seat. In the election of Table 1 there are 2 seats to be filled and 60 cast votes. The quota in this election is 21 votes.

[TABLE]

Each vote cast in the election starts with a value of 1. The total value of the votes a candidate has in their tally is computed as shown in Equation 2. As the STV algorithm proceeds, votes will move from the tally of one candidate to that of others. The value of these votes—the extent to which they contribute to a candidate’s tally value—will change over the course of the algorithm.

[TABLE]

Each vote is assigned to its first ranked candidate (Step 2). The first ranked candidate of vote [$c_{1},$ $c_{4},$ $c_{3}$] is $c_{1}$. The total value of the votes in each candidate’s tally is computed. Table 1(b) shows that the tally values of candidates $c_{1}$ to $c_{4}$ after this first round of counting are 26, 10, 9, and 15. The candidates whose tally value equals or exceeds the quota are placed in a list sorted in decreasing order of surplus size. A candidate’s surplus is equal to the difference between their tally value and the quota, as shown in Equation 3. In our example, $c_{1}$ is the only candidate whose tally has exceeded the quota with a surplus of 5 votes.

[TABLE]

If this list of candidates with a surplus (denoted surpluses in Figure 1) is not empty, we select the first candidate in this list, $c,$ and elect them to a seat (Step 9). If we have filled all available seats, the algorithm terminates (Step 10). Otherwise, we redistribute the votes in $c$’s tally. Each vote is placed in the tally of the next most preferred eligible candidate after $c$ in its ranking. Candidates that have been elected, eliminated, or whose tally value equals or exceeds the quota are not eligible. The set of votes in $c$’s tally that have no eligible next preferred candidate are exhausted (not redistributed). The remainder are labelled transferable (Step 11). These votes will have a reduced value when they are redistributed. Their current value is reduced by a factor $\tau$ known as the transfer value, computed (in Step 12) as shown in Equation 4.

[TABLE]

Consider our example in Table 1. Candidate $c_{1}$ is elected to a seat, and has 6 transferable votes with ranking [$c_{1},$ $c_{3}$]. The remaining votes in $c_{1}$’s tally have a ranking of [$c_{1}$]. These votes have no eligible next preference and are exhausted (not redistributed). The transfer value assigned to $c_{1}$’s transferable votes is 0.83. All 6 votes with ranking [$c_{1},$ $c_{3}$] are given to candidate $c_{3}$, but they now have a combined value of 5.

If, in Step 4, no candidate has a tally value that equals or exceeds the quota, the candidate $c$ with the smallest tally value is eliminated (Step 6). The votes in their tally are redistributed to later preferences. The votes in $c$’s tally that have $c$ as a first preference will have a value of 1 (as a consequence of Step 2). Votes that $c$ has received after prior surplus distributions will have a reduced value. All votes in $c$’s tally that have an eligible next preferred candidate (a candidate that is still standing) are given to that candidate at their current value (Step 7). If the contribution to $c$’s tally value of a vote is $v$, then that vote’s contribution to its next preferred candidate’s tally is also $v$. Consider again the example of Table 1. After the election of candidate $c_{1}$ and the redistribution of their votes, candidates $c_{2}$ to $c_{4}$ have tally values of 10, 14, and 15. No candidate has a quota of votes in their tally. Candidate $c_{2}$ has the smallest tally value, and is eliminated. Each of $c_{2}$’s votes—four with ranking [$c_{2},$ $c_{3}$] and 6 with ranking [$c_{2},$ $c_{3},$ $c_{4}$]—still have a value of 1 and are redistributed to candidate $c_{3}$. Candidates $c_{3}$ and $c_{4}$ now have tally values of 24 and 15.

After a candidate has been elected or eliminated, we check whether the number of unfilled seats and the number of remaining candidates (that have not yet been elected or eliminated) are equal (Step 14). If so, all remaining candidates are elected to a seat irrespective of their tally value (Step 15). If not, the total value of the votes in each remaining candidate’s tally is recomputed and we return to Step 4. In the example of Table 1, the algorithm recomputes the tally values of candidates $c_{3}$ and $c_{4}$ in Step 4, and places $c_{3}$ in the surpluses list. Candidate $c_{3}$ is elected to the final seat, and the algorithm terminates in Step 10. The STV algorithm proceeds in rounds that consist of: computing the total value of each candidate’s tally; electing the candidate with the largest surplus (if such a candidate exists) and redistributing their votes; or eliminating the candidate with the smallest tally value (if no candidate has a quota) and redistributing their votes.

Let us consider a second example STV election, shown in Table 2. Candidates $c_{1}$, $c_{2}$, $c_{3}$, and $c_{4}$ have initial tallies of 31, 17, 5, and 10 votes. The quota for the election is 22, and $c_{1}$ is placed into the list of candidates with a surplus in Step 4. Candidate $c_{1}$ is elected to the first of two available seats in Step 9, and has 13 transferable votes in their tally (Step 11). The transfer value to be applied to those votes is 0.69 (its surplus of 9 divided by the number of transferable votes 13). In Step 13, candidate $c_{2}$ is given 5 votes of ranking [$c_{1},$ $c_{3}$], with the total value of these votes equal to 3.46. Candidate $c_{4}$ is given 8 votes of ranking [$c_{1},$ $c_{4},$ $c_{2},$ $c_{3}$], with the total value of these votes equal to 5.54. In the second round of counting, $c_{2}$ now has a total tally value of 20.46 votes and $c_{4}$ a total tally value of 15.54. No candidate has a quota, and candidate $c_{3}$, with the smallest tally, is eliminated (in Step 6). Candidate $c_{2}$ is given 5 votes with ranking [$c_{3},$ $c_{2},$ $c_{4}$]. In the next round of counting, candidate $c_{2}$ has exceeded a quota and is elected to the last seat (Step 9).

In many STV variants, the last bundle of votes received by a candidate, at any point in the counting process, is known as their last parcel. In the Original Gregory Method, votes in an elected candidate’s last parcel (and no others) are transferred (at a fraction of their value) during surplus distribution. The total value of the votes transferred is equal to the candidate’s surplus. Some jurisdictions do not assign fractional values to distributed votes, but transfer a random selection of votes from a candidate’s last parcel at their full value, the total of which equals the candidate’s surplus. Much of the complexities involved in vote distribution across these variants are in place to support easier and faster manual vote counting. Weeks (2011) and Miragliotta (2004) provide a good summary of the range of STV variants used in practice.

3 Preliminaries

Definition 1 formally defines an STV election $\mathcal{E}$. Our representation of the outcome of an STV election—as a sequence of candidate elections and eliminations—is outlined in Definition 2. The margin of victory (MOV) of an STV election is defined in Definition 3. The primary vote of a candidate $c$ is computed as described in Definition 4, and used to compute simple upper bounds on the MOV of an STV election in Section 5.

Definition 1**.**

STV Election ($\mathcal{E}$) An STV election is defined as a tuple $\mathcal{E}=(\mathcal{C},\mathcal{B},\mathcal{Q},N,E)$ where $\mathcal{C}$ is a set of candidates, $\mathcal{B}$ the set of votes cast in the election, $\mathcal{Q}$ the election quota (the number of votes a candidate must attain to be elected to a seat, as defined in Equation 1), $N$ the number of seats to be filled, and $E$ the set of candidates elected to a seat (according to the counting algorithm outlined in Figure 1). Each vote $b\in\mathcal{B}$ is a partial or complete ranking over $\mathcal{C}$ (e.g., the vote $[c_{1},c_{3},c_{2}]$, in an election with candidates $\mathcal{C}=\{c_{1},c_{2},c_{3},c_{4}\}$, expresses a first preference for candidate $c_{1}$, a second for $c_{3}$, and a third for $c_{2}$).

Definition 2**.**

Election Order ($\pi$) Given an STV election $\mathcal{E}=(\mathcal{C},\mathcal{B},\mathcal{Q},N,E)$, we represent the outcome of the election as an election order $\pi$—a sequence of tuples $(c,a)$ where $c\in\mathcal{C}$ and $a\in\{0,1\}$. The tuple $(c,1)$ indicates that candidate $c$ is elected to a seat, and $(c,0)$ that $c$ is eliminated. An election order $\pi$ defines the sequence of elections and eliminations that arise as the STV counting algorithm (Figure 1) is executed. The order $\pi$ $=$ $[(c_{1},1),$ $(c_{3},0),$ $(c_{2},0),$ $(c_{4},1)]$, for example, indicates that candidate $c_{1}$ is elected to a seat in the first round of counting, followed by the elimination of candidates $c_{3}$ and $c_{2}$, and the election of $c_{4}$.

Definition 3**.**

Margin of Victory (MOV) The margin of victory for an STV election $\mathcal{E}=(\mathcal{C},\mathcal{B},\mathcal{Q},N,E)$ is defined as the smallest number of vote manipulations required to ensure that a set of candidates $E^{\prime}\neq E$ are elected to a seat (i.e., at least one candidate in $E^{\prime}$ must not appear in $E$). A single manipulation changes the ranking on a single vote $b$ to an alternate ranking. For example, consider a vote $b$ with ranking [$c_{1},$ $c_{3},$ $c_{2}$]. Replacing $b$’s ranking with the alternate ranking [$c_{4},$ $c_{1}$] represents a single manipulation.

Definition 4**.**

Primary Vote $f_{p}(c)$ The primary vote of a candidate $c\in\mathcal{C}$ in an STV election $\mathcal{E}=(\mathcal{C},\mathcal{B},\mathcal{Q},N,E)$ is defined as the total number of votes in $\mathcal{B}$ in which $c$ is ranked highest (i.e., $c$ is ranked first). For example, the vote $[c_{1},c_{3},c_{4}]$ contributes to the primary vote of candidate $c_{1}$.

4 Related Work

The computation of victory margins in both STV and Instant Runoff Voting (IRV) elections is NP-hard (Bartholdi III and Orlin, 1991; Conitzer et al., 2003, 2007; Xia, 2012; Rothe and Schend, 2013; Narodytska and Walsh, 2014). To the best of our knowledge, the algorithms presented in this paper form the first attempt to compute margins in STV elections. Blom et al. (2016) present a branch-and-bound algorithm for computing victory margins in IRV elections, itself an adaptation of earlier work by Magrino et al. (2011). An IRV election elects a single winner $w$ from a field of candidates $\mathcal{C}$ on the basis of the votes $\mathcal{B}$ cast in the election. As in an STV election, each vote $b\in\mathcal{B}$ is a (possibly partial) ordering over the candidates in $\mathcal{C}$. An IRV election proceeds in rounds of candidate elimination. Each vote is placed in the tally of the candidate $c$ that appears first in its ordering. In the first round, the candidate with the least votes in their tally is eliminated. Each of these votes is placed in the tally of its next preferred candidate. Votes with no next preferred candidate become exhausted (are not redistributed). This process of candidate elimination is repeated until only a single candidate remains—this candidate is the winner of the election. Unlike IRV, STV elects multiple candidates with the counting algorithm alternating between rounds of candidate election and candidate elimination. The votes in the tallies of elected candidates are redistributed at a reduced value.

Magrino et al. (2011) represent the outcome of an IRV election as a candidate sequence $\pi$ with candidates listed in the order in which they are eliminated (with the last candidate being the winner). Given such a sequence $\pi$, and a collection of votes, a linear program (LP) is presented that computes the smallest number of vote manipulations required to realise $\pi$. This linear program is labelled DistanceTo. In an election with winner $w$, Magrino et al. (2011) search the space of alternate elimination sequences (in which a candidate other than $w$ is elected) for one requiring the least number of vote manipulations to realise. A key observation made by Magrino et al. (2011) is that, given a partial sequence of candidates $\pi^{\prime}$, the DistanceTo LP computes a lower bound on the number of vote manipulations required to realise any elimination order that ends in $\pi^{\prime}$. Magrino et al. (2011) progressively explore and build partial candidate elimination orders in a branch-and-bound algorithm. The last round margin (LRM) of the election (defined as the difference in the tallies of the winning candidate and runner-up, divided by two and rounded up) is used as an upper bound on the MOV. Consider an IRV election with candidates $c_{1}$, $c_{2}$, $c_{3}$, and $c_{4}$, with outcome [$c_{4},$ $c_{3},$ $c_{2},$ $c_{1}$], where $c_{1}$ is the winning candidate. Partial orders containing a single candidate (not including the original winner $c_{1}$) are added to a tree. DistanceTo is applied to each partial order $\pi^{\prime}$ in this tree to compute a lower bound on the number of vote manipulations required to realise an elimination sequence ending in $\pi^{\prime}$. The partial order $\pi^{\prime}$ with the smallest DistanceTo evaluation is expanded by adding a candidate (not already in $\pi^{\prime}$) to the start of the sequence. Partial orders with evaluations equal to or larger than the current upper bound are pruned. When a complete elimination order (involving all candidates) is formed, its DistanceTo evaluation is used to revise the current recorded upper bound. The algorithm terminates once all partial orders have either been expanded or pruned, with the revised upper bound returned as the MOV.

Blom et al. (2016) improve the efficiency of the branch-and-bound algorithm of Magrino et al. (2011) by introducing new rules for computing lower bounds on the manipulation required to realise each partial order in the search tree. These rules typically result in tighter (i.e., higher) lower bounds for each partial order than supplied by solving the DistanceTo LP. Consequently, Blom et al. (2016) are able to: prune larger portions of the space of partial elimination sequences; reduce the number of calls to the DistanceTo LP; and quickly compute margins in elections for which the algorithm of Magrino et al. (2011) times out after 72 hours of computation. Our margin-stv algorithm shares a similar structure to that of Blom et al. (2016) and Magrino et al. (2011), in that it searches the space of alternate election and elimination sequences using branch-and-bound. The margin-stv algorithm differs in several key aspects: each node is a partial sequence of candidate elections and eliminations (in place of a sequence of eliminations); a MINLP (in place of an LP) is used to evaluate nodes in this search tree; and the descendants of a partial sequence $\pi^{\prime}$ are all complete sequences that start with $\pi^{\prime}$ (in place of all sequences than end in $\pi^{\prime}$). Moreover, a variation of the winner elimination upper bound for IRV elections (Cary, 2011) is used as an initial upper bound on the STV MOV (as described by Chilingirian et al. (2016)). Section 8 describes the margin-stv algorithm in detail.

The winner elimination upper bound (on the IRV margin of victory) of Cary (2011) finds the most efficient way to eliminate the apparent winner of an IRV election at each elimination round, returning the least-cost (involving the smallest number of vote changes) of these. Chilingirian et al. (2016) develop a version of this upper bound for use in STV elections. Figure 2 outlines this STV variant of the winner elimination upper bound. Consider the example STV election of Table 1, where $c_{1}$ was elected in the first round of counting, $c_{2}$ eliminated in the second, and $c_{3}$ elected in the third (at which point both available seats had been filled). Following the algorithm listed in Figure 2, the winner elimination upper bound ($weub$) is initially set to the total number of votes cast in the election (Step 1), which is 60. The set of candidates that are (eventually) elected is $E$ $=$ {$c_{1},$ $c_{3}$}. In the first round of counting, a candidate ($c_{1}$) is elected. The algorithm moves on to the second round (Step 3), in which a candidate ($c_{2}$) is eliminated with 10 votes ($v_{2}=10$ in Step 6). In Step 7, we consider each candidate in $E$ that has not been elected by round 2—candidate $c_{3}$—and determine how they could be eliminated in this round. Candidate $c_{3}$ has 14 votes in round 2 ($w_{2}=14$ in Step 8). We could certainly eliminate $c_{3}$ by taking 4 votes from their tally ($\Delta=4$ in Step 9) and giving them to some other candidate ($c_{2}$, for example). However, candidate $c_{3}$ can still be eliminated in this round if we take 2 votes from their tally and give them to $c_{2}$ (Steps 11 and 12), under the assumption that we can break the resulting tie between $c_{3}$ and $c_{2}$ in $c_{2}$’s favour. The winner elimination upper bound is set to 2 in Step 12. The algorithm moves on to the last round of counting in which no candidate is eliminated. Steps 5 to 12 are skipped and a winner elimination upper bound of 2 is returned.

To the best of the authors knowledge, the work of Chilingirian et al. (2016) describes the only attempt to compute bounds on the MOV for STV elections (in its adaptation of the winner elimination upper bound of Cary (2011)). The algorithms we present in this paper are, to the best of our knowledge, the first attempts to compute exact margins in small STV elections and lower bounds on the MOV in larger instances. IRV elections, in contrast, have received more consideration. Blom et al. (2016) and Magrino et al. (2011) present algorithms for computing exact margins in IRV elections. A number of works have presented algorithms for computing lower and upper bounds on IRV margins (see Cary (2011) and Sarwate et al. (2013)).

The focus of this paper is the computation of the MOV for STV elections. This MOV is defined as the smallest number of vote manipulations (the replacing of the ranking of a vote with an alternate ranking) required to ensure that a different set of candidates is elected (i.e., at least one candidate in this set is replaced with one that was not originally elected to a seat). Similar questions have been considered for alternate voting rules. The complexity of manipulating an election with bribery is considered by Faliszewski et al. (2009), under a number of voting schemes: Condorcet-based; approval voting; scoring rules; veto rules; and plurality. Their aim is to find a manipulation to achieve a desired election result, while minimising the cost of bribes given to voters for changing their vote. If the cost of bribing a voter to change their vote is 1, this least cost set of bribes is equivalent to the margin of victory, as we have defined it. Kaczmarczyk and Faliszewski (2016) consider a variant of the bribery problem (destructive shift bribery) in which voters can be bribed to demote the position of a candidate $c$ in their ranking by $p$ positions (i.e., to move a candidate down in their ranking by $p$ positions) in a bid to ensure that $c$ does not win the election. The authors analyse the complexity of destructive shift bribery for a number of voting rules ($k$-Approval, Borda, Copeland and Maximin). Polynomial-time algorithms are presented for computing the smallest set of desired bribes in the case of the k-Approval, Borda, and Maximin rules, while the problem is shown to be NP-complete for the Copeland rule. Schürmann (2017) describe a model-checking-based approach for the computation of margins in D’Hondt elections, applying their approach to the 2015 Danish national parliamentary elections. The STV elections we consider in this paper vary considerably from the voting rules considered by Kaczmarczyk and Faliszewski (2016), and Schürmann (2017). We refer the reader to Brandt et al. (2016) for further discussion on bribery and manipulation problems in the computational social choice context.

Given an STV election $\mathcal{E}$, our margin-stv algorithm relies on: a mechanism for computing an upper bound on the manipulation required to change the outcome of $\mathcal{E}$; a mechanism for computing the smallest manipulation required to realise a specific outcome for $\mathcal{E}$—a specific sequence of candidate eliminations and elections $\pi$; and a mechanism for computing a lower bound on the degree of manipulation required to realise a candidate order that starts with a partial sequence of elections and eliminations $\pi^{\prime}$. These mechanisms are provided in Sections 5 to 7, and form the basis of our branch-and-bound algorithm.

5 Simple Upper Bounds on the STV MOV

Figure 2 presents an algorithm for computing an upper bound (a winner elimination upper bound) on the STV MOV222This algorithm has been extracted from the work of Chilingirian et al. (2016). The algorithm is not explicitly presented in that paper, but can be found in code, implemented by Andrew Conway, for analysing the 2012 local government elections in New South Wales, Australia. This code is available at: https:/github.com/SiliconEconometrics/PublicService. In elections where all seats are filled by a candidate prior to any eliminations taking place (e.g., an election with 2 seats, 4 candidates, and outcome [$(c_{1},1)$ $(c_{2},1),$ $(c_{3},0),$ $(c_{4},0)$]), this algorithm is not able to reduce the upper bound from its original value (the total number of votes cast in the election). In these instances, we introduce a simple bound on the STV MOV, computed as follows. Consider an election $\mathcal{E}=(\mathcal{C},\mathcal{B},\mathcal{Q},N,E)$. The STV counting algorithm of Figure 1 elects candidates to a seat once the number of votes in their tally reaches or exceeds $\mathcal{Q}$. To change the outcome of $\mathcal{E}$, with winning candidates $E\subset\mathcal{C}$, we must find a series of vote manipulations that elects a candidate $c\in\mathcal{C}\setminus E$ to a seat. It is clear that we can elect $c\in\mathcal{C}\setminus E$, with primary vote $f_{p}(c)$ (the total number of votes in $\mathcal{B}$ in which $c$ is ranked first), if we take $\mathcal{Q}-f_{p}(c)$ votes away from other candidates and give them to $c$ (we replace the ranking of these votes by a ranking that preferences $c$ first). We compute $\mathcal{Q}-f_{p}(c)$ for each $c\in\mathcal{C}\setminus E$ and take the smallest result as an upper bound on the STV MOV. We call this bound the Simple-STV upper bound.

6 Computing Minimal Manipulations: A MINLP

Given an IRV election and a sequence of candidate eliminations $\pi^{\prime}$, Magrino et al. (2011) present a linear program (LP) for computing the smallest number of vote manipulations required to ensure candidates are eliminated in the order specified in $\pi^{\prime}$. In this section, we present a mixed-integer non-linear program (MINLP) that, given an STV election $\mathcal{E}=(\mathcal{C},\mathcal{B},\mathcal{Q},N,E)$, and a candidate order $\pi$ (a sequence of candidate elections and eliminations), computes the smallest number of vote manipulations (changes to votes in $\mathcal{B}$) required to realise $\pi$. We re-use some notation and constraints introduced in the LP of Magrino et al. (2011). The votes in $\mathcal{B}$ form the original profile of the election. The MINLP below, denoted DistanceToSTV, introduces variables indicating which votes in $\mathcal{B}$ are to be changed, and what their ranking will be in a new or modified profile. The constraints of the following MINLP are designed to enforce a specific candidate order $\pi$ by modifying the smallest number of votes in $\mathcal{B}$ (where required).

6.1 Notation

Sets and Indices

Constants

Decision Variables

6.2 Objective

The objective of DistanceToSTV is to minimise the number of votes in $\mathcal{B}$ whose signature is changed.

[TABLE]

6.3 Constraints

Constraints (6) and (7) appear in the LP of Magrino et al. (2011). Constraint (6) ensures that the total number of votes in the new election profile (after manipulation) is equal to the total number of votes in the original profile. This assumption is made by both Blom et al. (2016) and Magrino et al. (2011). Blom et al. (2016) explore variations of the DistanceTo LP of Magrino et al. (2011) in which this constraint is removed, and a manipulation may add votes (for example, arising from voters voting multiple times), or remove votes (for example, arising from ballot box losses). We intend, in future work, to consider the ‘deletion-only’ and ‘addition-only’ settings analysed by Blom et al. (2016) for IRV elections, in the STV setting. Constraint (7) defines the number of votes with signature $s\in\mathbf{S}$ in the new profile, $y_{s}$.

[TABLE]

Constraint (8) ensures that candidates who have achieved a quota by round $j$, have also achieved a quota by round $j+1$. Constraints (9) and (10) ensure that that number of votes a candidate $i$ has in their tally at the start of round $j$ is greater than or equal to $\mathcal{Q}$ if $i$ has achieved a quota by round $j$ ($q_{ij}$ is 1) and less than $\mathcal{Q}$ otherwise ($q_{ij}$ is 0, and $\epsilon\ll 1$).

[TABLE]

Constraints (11) and (12) define the number of votes of signature $s\in\mathbf{S}$ in candidate $i$’s tally at the start of round $j$. Where $j>1$, this is equal to the number of votes of signature $s\in\mathbf{S}$ in candidate $i$’s tally at the start of the previous round, plus the number of votes of signature $s\in\mathbf{S}$ distributed to $i$ from the candidate elected (or eliminated) in round $j-1$. As all votes of a single signature $s$ will reside in the tally of only one candidate at any point in time, at least one of $y_{i,j-1,s}$ and $d_{i,j-1,s}$ will be zero in each instance of Constraint (12). Although the order in which candidates are elected and eliminated is fixed (to that defined by $\pi$), the round in which a candidate is given, via distribution, votes of certain signatures can vary. Consider a candidate $c$ whose tally has reached or exceeded the quota in round $j$. Candidate $c$ may have to wait several rounds to be elected to a seat, if one or more other candidates have also reached a quota by round $j$, and have more votes in their tallies (they are elected before $c$). While candidate $c$ is waiting to be elected, they are not given any additional votes during the distribution of the surpluses of elected candidates—these votes skip $c$ and are given to the next eligible candidate in their ranking. As the candidate order $\pi$ does not prescribe exactly when an elected candidate achieves a quota, we must support the possibility that votes of certain signatures $s\in\mathbf{S}$ can be distributed to a candidate in one of a number of different rounds. Constraint (13) sums the total number of votes for candidate $i$ at the start of round $j$.

[TABLE]

Constraint (14) ensures that the candidate elected to a seat in round $j$ has more (or an equal number of) votes in their tally at the start of round $j$ than all other candidates who are still standing (have not been eliminated or elected before round $j$). Conversely, a candidate who is eliminated in round $j$ must have fewer (or an equal number of) votes in their tally at the start of round $j$ than all other candidates who are still standing (Constraint (15)). Moreover, a candidate can only be eliminated in a round if no other remaining candidate has a quota’s worth of votes in their tally at the start of the round (Constraint (16)).

[TABLE]

Constraint (17) defines the value of variable $d_{ijs}$ (the total number of votes of signature $s$ distributed to candidate $i$ in round $j$ after candidate $\pi[j]$ is elected or eliminated). Recall that the set $\mathcal{P}_{ij}$ denotes the subset of signatures $s\in\mathbf{S}$ that could possibly be in candidate $i$’s tally at the start of round $j$. The set $\mathcal{P}_{\pi[j],j}\cap\mathcal{P}_{i,j+1}$ contains only those signatures that could possibly be distributed from $\pi[j]$ (the candidate elected or eliminated in round $j$) to candidate $i$—the subset of signatures that could have been in $\pi[j]$’s tally in round $j$ and in the tally of candidate $i$ at the start of round $j+1$. If $\pi[j]$ is eliminated ($\pi[j]\in\pi^{-}$), any votes distributed to another candidate are distributed at their current value ($d_{ijs}=y_{\pi[j],j,s}$ for all $s\in\mathcal{P}_{\pi[j],j}\cap\mathcal{P}_{i,j+1}$). If $\pi[j]$ is elected, candidate $i$ may receive their votes of signature $s\in\mathcal{P}_{\pi[j],j}\cap\mathcal{P}_{i,j+1}$ (at a reduced value) only if $i$ does not already have a quota’s worth of votes and is either the next preferred candidate in $s$, or all candidates that appear between $\pi[j]$ and $i$ in $s$ already have a quota’s worth of votes.

[TABLE]

Upon the election of a candidate $c$, a subset of the votes in their tally (those for which there is a next preferred candidate that is still standing—not yet eliminated or elected—and whose tally has not already reached or exceeded the quota) are distributed to one or more alternate candidates. These votes are called transferable votes. The remainder become exhausted (there is no such ‘next preferred’ candidate for these votes). The number of transferable votes in a candidate $c$’s tally, upon their election in round $j$, denoted $\rho_{j}$, is defined in Constraint (18). The transfer value assigned to these votes is dependent on both the size of $c$’s surplus (the value of votes in their tally minus the quota) and the total value of the transferable votes in $c$’s tally (the votes that have a valid next preferred candidate). This transfer value $\tau_{j}$, and its relationship to the quantity of transferable votes in an elected candidate’s tally $\rho_{j}$, is defined in Constraint (19). Both of these variables are relevant only in rounds in which a candidate is elected to a seat, and a surplus is distributed.

[TABLE]

Constraint (19) yields incorrect transfer values—that are greater than one—in the event that the total value of the transferable votes in an elected candidate $c$’s tally is less than their surplus. This can occur if a large portion of $c$’s votes become exhausted once they are elected (votes that define a partial ordering over the set of candidates become exhausted when the last candidate in their ordering is eliminated or elected). In this circumstance, the transfer value of $c$’s transferable votes is set to 1 (i.e., these votes are distributed at their current value). This is consistent with how STV elections are counted in practice. Constraint (19) is thus rewritten as shown in Constraint (20).

[TABLE]

7 Computing Lower Bounds for Partial Candidate Orders

Magrino et al. (2011) present an LP for computing the smallest number of vote manipulations required to realise a sequence of candidate eliminations in a given IRV election. This LP, when applied to a partial elimination sequence $\pi^{\prime}$ (under the assumption that all candidates not in $\pi^{\prime}$ have already been eliminated and their votes distributed to candidates in $\pi^{\prime}$), computes a lower bound on the manipulations required to realise an elimination sequence ending in $\pi^{\prime}$. Similarly, we can apply DistanceToSTV to a partial sequence of candidate elections and eliminations $\pi^{\prime}$ (a partial candidate order) to compute a lower bound on the manipulations required to realise a complete order (including all candidates) that starts with $\pi^{\prime}$.

Consider the STV election of Table 1 with candidates $c_{1},$ $c_{2},$ $c_{3},$ and $c_{4}$. Given the partial order [$(c_{1},0),$ $(c_{3},1)$], DistanceToSTV computes the smallest number of vote manipulations required to ensure that:

• •

Candidate $c_{1}$ has the fewest votes in the 1st round of counting (fewer votes than $c_{2}$, $c_{3}$, and $c_{4}$);

• •

No candidate has a quota’s worth of votes in their tally in the 1st round;

• •

Candidate $c_{3}$ has a quota’s worth of votes in their tally in the 2nd round; and,

• •

Candidate $c_{3}$ has the most votes in their tally in the 2nd round (more votes than $c_{2}$ and $c_{4}$).

For any complete order $\pi$ that starts with [$(c_{1},0),$ $(c_{3},1)$], DistanceToSTV will ensure that the above constraints hold in addition to constraints that enforce the remaining elections and eliminations in $\pi$. For any partial order $\pi^{\prime}$, the set of constraints enforced by DistanceToSTV is a subset of those enforced for any complete order starting with $\pi^{\prime}$. Consequently, solving DistanceToSTV for $\pi^{\prime}$ yields a lower bound on the manipulations required to realise any complete order starting with $\pi^{\prime}$. This property of the DistanceToSTV MINLP allows us to form a branch-and-bound algorithm for computing the MOV in STV elections.

7.1 A Simple Lower Bounding Rule

Blom et al. (2016) present two methods for computing lower bounds on the degree of manipulation required to realise IRV elimination sequences that end in a partial order $\pi^{\prime}$, without requiring the solving of an LP. We adapt the logic underlying these rules to develop a lower bounding rule applicable to partial orders in STV elections. Given a partial order $\pi^{\prime}$ (a sequence of candidate eliminations and elections), this rule computes a lower bound on the number of vote manipulations required to realise any complete order starting with $\pi^{\prime}$.

Consider an STV election $\mathcal{E}=(\mathcal{C},\mathcal{B},\mathcal{Q},N,E)$, and a partial order $\pi^{\prime}$. We can infer from $\pi^{\prime}$, the set of vote signatures $s\in\mathbf{S}$ that could potentially lie in the tally of each candidate $c\in\mathcal{C}$ in each round of election or elimination $j$ in $\pi^{\prime}$ (this set is denoted $\mathcal{P}_{cj}$, as defined in Section 6.1). Consequently, we can infer the maximum possible number of votes that could lie in the tally of each candidate $c$ in each round $j$ (the total number of votes cast with a signature $s\in\mathcal{P}_{cj}$), $V^{max}_{cj}$, under the assumption that no manipulation has yet taken place (Equation 21). Recall that $N_{s}$ denotes the number of votes in $\mathcal{B}$ that have been cast with signature $s\in\mathbf{S}$. Irrespective of when a candidate $c$ is elected or eliminated, $c$’s tally will contain at least all cast votes in which they are the first preference (their primary vote $f_{p}(c)$, as per Definition 4). The minimum number of votes in $c$’s tally, in any round $j$, $V^{min}_{c}$, is equal to $c$’s primary vote (Equation 22).

[TABLE]

We consider each election and elimination in $\pi^{\prime}$. Let $c_{j}$ denote the candidate elected or eliminated in round $j$ of $\pi^{\prime}$. If $c_{j}$ is elected, $c_{j}$ must have a quota’s worth of votes in their tally (unless the number of seats left to be filled in round $j$ equals the number of candidates still standing at the start of round $j$). To ensure that $c_{j}$ has a quota’s worth of votes at the start of round $j$, we must modify at least $l_{q}$ votes (Equation 23).

[TABLE]

If candidate $c_{j}$ is eliminated, $c_{j}$ must have fewer votes than all other candidates still standing at the start of round $j$, denoted $\mathcal{S}_{j}$, and no remaining candidate can have a quota’s worth of votes. To ensure that $c_{j}$ has fewer votes than all candidates in $\mathcal{S}_{j}$, we must modify at least $l^{1}_{e}$ votes (Equation 24). To ensure that no remaining candidate has a quota’s worth of votes at the start of round $j$, we must modify at least $l^{2}_{e}$ votes (Equation 25). To ensure that $c_{j}$ is eliminated in round $j$, we must modify at least $l_{e}=\max(l^{1}_{e},l^{2}_{e})$ votes.

[TABLE]

Equation 25 will ensure that no candidate has more than a quota’s worth of votes in round $j$. To ensure that a candidate has less than a quota, their tally value must be less than or equal to $\mathcal{Q}-\epsilon$, where $\epsilon\ll 1$. As we are computing a lower bound on required vote manipulation, we ignore the $\epsilon$ term for simplicity.

A lower bound on the degree of manipulation required to realise a complete order starting with $\pi^{\prime}$ is computed by taking the maximum of $l_{q}$ and $l_{e}$ for each candidate elected, and eliminated, in $\pi^{\prime}$.

[TABLE]

Example 1**.**

Consider the STV election of Table 1 and the candidate order $\pi$ $=$ [($c_{3},$ 0), ($c_{1},$ 1), ($c_{2},$ 1), ($c_{4},$ 0)], where candidate $c_{3}$ is eliminated in Round 1, $c_{1}$ is elected in Round 2, and $c_{2}$ is elected Round 3. We now use our lower bounding rule to compute a lower bound on the number of vote manipulations required to realise this order of elections and eliminations. The original winners in this election are candidates $c_{1}$ and $c_{3}$ ($E=\{c_{1},c_{3}\}$). Given the cast votes listed in Table 1(a), we determine where these vote signatures would lie (i.e., in which candidates tally), in each round of counting (until all seats have been filled), assuming $\pi$ is realised (Table 3(a)). Prior to any manipulation of the cast votes, the maximum value of each candidates tally, in each round, is listed in Table 3(b).

The minimum value of each candidates tally, in each round, is equal to their primary vote. Here, $V^{min}_{c_{1}}=26$, $V^{min}_{c_{2}}=10$, $V^{min}_{c_{3}}=9$, and $V^{min}_{c_{4}}=15$. We consider each election and elimination in $\pi$. To eliminate $c_{3}$ in Round 1, $c_{3}$ must have fewer votes than all other candidates. Here, $l^{1}_{e}(c_{3},\pi)=0$ (no manipulation is required to ensure $c_{3}$ has the fewest votes). No candidate can have a quota’s worth of votes in Round 1. In this example, the quota is 21 votes, $l^{2}_{e}(c_{3},\pi)=5$, and $l_{e}(c_{3},\pi)=5$. To elect $c_{1}$ in Round 2, we must ensure that $c_{1}$ has a quota in Round 2. Here, $l_{q}(c_{1},\pi)=\max(0,\mathcal{Q}-V^{max}_{c_{1}2})=\max(0,21-26)=0$. To elect $c_{2}$ in Round 3, we must ensure that $c_{2}$ has a quota in Round 3. Here, $l_{q}(c_{2},\pi)=\max(0,\mathcal{Q}-V^{max}_{c_{2}3})=\max(0,21-10)=11$. Consequently, a lower bound on the manipulation required to realise $\pi$ is $lb(\pi)$ $=$ $\max\{l_{e}(c_{3},\pi),$ $l_{q}(c_{1},\pi),$ $l_{q}(c_{2},\pi)\}$ $=$ $\max\{5,0,11\}$ $=$ $11$.

We describe, in Section 8, how this lower bounding rule can be used to avoid solving the DistanceToSTV MINLP for some partial orders explored by the margin-stv algorithm.

8 Computing Margins in STV Elections (margin-stv)

Figure 3 defines our margin-stv algorithm for computing the MOV of an STV election. The margin-stv algorithm maintains an initially empty frontier of partial candidate orders $F$ (Step 1). An upper bound $UB$ on the STV MOV is computed in Step 2. In our implementation of margin-stv we use the minimum of the winner elimination upper bound of Figure 2 and the Simple-STV upper bound of Section 5. The frontier $F$ is populated with partial candidate orders of size one (the election or elimination of a single candidate)—each of which is assigned a lower bound on required manipulations with DistanceToSTV—in Steps 4 – 9. Partial orders with a lower bound less than the current upper bound $UB$ are added to $F$ in Step 9.

Example 2**.**

Consider the STV election of Table 1. The winner elimination upper bound is 2 votes and the Simple-STV bound is 6 votes. In Step 2, the current upper bound $UB$ is initialised to 2. The partial candidate orders $[(c_{1},0)],$ $[(c_{1},1)],$ $[(c_{2},0)],$ $[(c_{2},1)],$ $[(c_{3},0)],$ $[(c_{3},1)],$ $[(c_{4},0)],$ and $[(c_{4},1)]$ are created, and assigned lower bounds by DistanceToSTV* of 11, 0, 6, 11, 6, 12, 8, and 6, respectively. Only $[(c_{1},1)]$ is added to $F$ in Step 9. Figure 4 visualises the search tree explored by margin-stv in this example.*

Once the frontier $F$ is populated with partial orders of size one, Steps 10 to 14 expand these orders in the search for an alternate outcome for the election that requires the smallest degree of manipulation to realise. Partial orders with the smallest assigned lower bound are expanded in turn. A partial order $\pi^{\prime}$ is expanded by first removing it from the frontier (Step 12). For each candidate $c$ not mentioned in $\pi^{\prime}$, two new partial orders are formed in which $c$ is elected ($\pi^{\prime}+\!\!+[(c,1)]$) and eliminated ($\pi^{\prime}+\!\!+[(c,0)]$) in successive iterations of the loop in Steps 18 to 26. If the new partial order $\pi$ is valid (i.e., it does not elect the same candidates elected in the original winners set $E$), it is evaluated with DistanceToSTV (Step 21). If $\pi$ contains all candidates (it is a complete order), it represents an alternate election outcome requiring $l$ vote manipulations to realise ($l$ is computed by DistanceToSTV in Step 21). If $l$ is less than the current upper bound, $UB$, $UB$ is replaced with $l$ (Step 23). If $\pi$ is not a complete order, it is added to $F$ if $l$ is less than $UB$ (Step 26).

We repeatedly expand the partial order with the smallest assigned lower bound, updating the frontier $F$, until $F$ is empty (there are no remaining partial orders that can be expanded). At this point, the algorithm terminates and returns the current upper bound $UB$ as the election MOV in Step 15.

Example 3** (Example 2 cont).**

The frontier, $F$, now contains one partial order $\pi^{\prime}$ $=$ $[(c_{1},1)]$. The following partial orders are formed and evaluated with DistanceToSTV* in successive executions of Step 19 and 21:*

Only $[(c_{1},1),$ $(c_{2},0)]$ is added to $F$ in Step 26. At this point, $F$ $=$ $\{[(c_{1},1)$, $(c_{2},0)]\}$, and $[(c_{1},1)$, $(c_{2},0)]$ is the next order expanded in Step 13. The following complete orders are formed in successive executions of Step 19 (in our implementation of margin-stv, we complete all partial orders formed in Step 19 with their ‘obvious’ ending if possible—i.e., if there is only one candidate remaining). All orders have a lower bound greater than the current upper bound of 2, and are pruned from consideration.

After pruning all partial orders from $F$, the frontier is empty and the algorithm returns the upper bound of 2 as the election MOV in Step 15. In this example, margin-stv has shown that there is no better manipulation (requiring fewer vote changes) than that inferred by the winner elimination upper bound.

In Steps 7 and 21, where DistanceToSTV is evaluated for a partial (or complete) order $\pi$, we can use the lower bounding rule of Section 7.1 to compute an initial lower bound for $\pi$, $l^{\prime}$. If $l^{\prime}\geq UB$, the current upper bound, we need not solve DistanceToSTV as $\pi$ can immediately be pruned from consideration. If $l^{\prime}<UB$, we can solve DistanceToSTV to get a second lower bound for $\pi$, $l$. We can then assign to $\pi$ the maximum of the two lower bounds $l^{\prime}$ and $l$. In Section 9, we examine the relative performance of margin-stv, in terms of the number of DistanceToSTV MINLPs solved and the runtime of the algorithm, in the setting where this extra lower bounding computation is performed, and when it is omitted.

8.1 Implementation Details

We use SCIP (Achterberg, 2009) to solve each MINLP formed by margin-stv. In practice, we have found that some instances of DistanceToSTV, even for small election instances, can be difficult for SCIP to solve in reasonable time. Consequently, we terminate MINLP solves if the time since a last improving solution has been found reaches a pre-specified time limit. If a partial order $\pi^{\prime}$ is being evaluated, and the MINLP is terminated before an optimal solution is found, the best objective value (a lower bound on the optimal objective) is assigned to $\pi^{\prime}$ as its lower bound. If a complete order $\pi$ is being evaluated, and the MINLP is terminated before finding an optimal solution, $\pi$ is inserted into the frontier $F$ with a lower bound equal to the best objective value of the MINLP, and the current upper bound is not revised (as would normally occur after evaluating a complete order). The result is that margin-stv may terminate with a frontier that contains a number of complete orders (that cannot be further expanded) with a smallest lower bound $L$, and a current upper bound $UB$ that is greater than $L$ (i.e., the algorithm returns with a lower and upper bound on the MOV, but not an exact value). This occurs for a number of elections in our test set in Section 9.

It is clear from the evaluation of margin-stv, in Section 9, on small STV elections (with candidate numbers ranging from 4 to 13) that it will not scale to more realistic elections with dozens of candidates. To improve its scalability, we vary the algorithm so that a MIP relaxation of the DistanceToSTV is constructed to evaluate each partial and complete order formed in Steps 6 and 19 of Figure 3. We consider two types of relaxation. The first replaces each bilinear term present in the MINLP (these terms appear in Constraints (17) and (20)) with McCormick (1976) inequalities. Each bilinear term $x\,y$, where $x$ and $y$ are continuous variables with domains $[x^{L},x^{U}]$ and $[y^{L},y^{U}]$, is replaced with variable $z=x\,y$. Variable $z$ is defined by Equations (27) to (30). The optimal solution of the relaxed DistanceToSTV is a lower bound on that of the MINLP. The MOV computed by margin-stv, in this context, is a lower bound on the true MOV. An illustration of the McCormick envelope is shown in Figure 5(a) when $z$ is fixed.

[TABLE]

Our second relaxation replaces each bilinear term present in the MINLP (these terms appear in Constraints (17) and (20)) with a piecewise linear relaxation (specifically, a relaxation proposed by Gounaris et al. (2009)). The result is again a MIP relaxation of the DistanceToSTV whose optimal solution is a lower bound on that of the MINLP. Given a product of two continuous variables $x$ and $y$ (a bilinear term $x\,y$), the piecewise linear relaxation we apply is defined as follows (replicated from the work of Gounaris et al. (2009)), where the variable $z=x\,y$ replaces the bilinear term where it appears in the original MINLP. We divide the domain of $x$ into $K$ ranges ($[x_{0},x_{1}],$ $\ldots,$ $[x_{k-1},x_{k}]$) and introduce a binary variable $\lambda_{k}$ to indicate whether $x$ has a value in range $[x_{k-1},x_{k}]$. Constraint (31) ensures that only one $\lambda_{k}$ can take on a value of

1. The domain of variable $y$ is $[y^{L},y^{U}]$. The variable $\delta y_{k}$ defines the “deviation of variable $y$ from its lower bound $y^{L}$, if $x\in[x_{k-1},x_{k}]$” and is set to 0 if the value of $x$ lies outside of this range (Gounaris et al., 2009). Figure 5(b) shows how the relaxation improves when we break the domain of $x$ into two ranges $x_{l}..x_{m}$ and $x_{m}..x_{u}$.

[TABLE]

In the DistanceToSTV MINLP, variables $\tau_{j}$ and $y_{\pi[j],j,s}$ (Constraint (17)), and $\tau_{j}$ and $\rho_{j}$ (Constraint (20)) participate in bilinear terms. We treat the transfer value of votes distributed from the candidate elected in round $j$, $\tau_{j}$, as $x$ in the piecewise linear relaxation scheme presented above, with variables $y_{\pi[j],j,s}$ (the total value of votes of signature $s$ in the tally of candidate $\pi[j]$ at the start of round $j$) and $\rho_{j}$ (the number of transferable votes in the tally of the candidate elected in round $j$) as $y$. In Section 9, we discretise the domain of $\tau_{j}$ into varying numbers of segments (by varying $K$), and compare the resulting lower bounds (on margins) found by margin-stv to the true MOV found when no such relaxation is used.

In their algorithm for computing margins in IRV elections, Magrino et al. (2011) recognise that their DistanceTo LP, defined to compute the smallest number of vote changes required to realise a particular (partial or complete) elimination order, need only consider a subset of possible vote signatures (in place of all possible partial and total orderings over the set of candidates). Given an elimination order $\pi$, specifying which candidates are eliminated in each counting round, Magrino et al. (2011) note that classes of ballot signatures, denoted equivalence classes, will behave in the same way (be transferred between candidates in the same way) as counting progresses. Consequently, each DistanceTo LP need only contain variables defining the number of votes of each equivalence class present in the modified election profile. The definition of equivalence classes presented by Magrino et al. (2011) can be applied in the context of both IRV and STV elections, given an elimination sequence (for an IRV election) and a sequence of elections and eliminations (for an STV election). In our implementation of margin-stv, we define the DistanceToSTV MINLP (and its relaxations) over signature equivalence classes (i.e., the set $\mathbf{S}$ contains the signatures of all equivalence classes, in place of all partial and total orders over the set of candidates $\mathcal{C}$).

9 Evaluation

We first evaluate margin-stv on a set of small STV elections. To do so, we take 16 IRV elections conducted in the US between 2007 and 2010, and re-imagine them as STV elections with 2 available seats (Appendix A lists the names of each of these elections, alongside the number of candidates, and number of votes cast). The number of candidates in these elections range between 4 and 13. All experiments in this paper have been conducted on a machine with an Intel Xeon ES-2440 2.40GHz 6 core processor, and 64GB of RAM.

Table 4 reports the results of margin-stv – without and with the use of the lower bounding rule of Section 7.1 – on 16 small IRV (re-imagined as STV) elections. We record: the number of candidates $|\mathcal{C}|$ in the election; the best computed upper bound on the MOV (the minimum of the winner elimination and Simple-STV upper bound); the MOV returned by margin-stv (or bounds on the MOV); the number of DistanceToSTV MINLPs solved by the algorithm; and the time taken by margin-stv to compute the MOV (in seconds). SCIP (Achterberg, 2009) is used to solve all DistanceToSTV MINLPs. We terminate each run of margin-stv after 12 hours, and infer a lower and upper bound on the MOV from the state of the frontier. Our algorithm did not terminate for three instances (13, 14, and 16) within 12 hours. In 11/16 instances, our algorithm could not produce an exact MOV, but a lower and upper bound on the MOV. In 7/11 instances, the lower and upper bound differed by only 1 vote (i.e., margin-stv was able to produce very tight bounds on the MOV). Table 4 shows that our lower bounding rule can, in some instances, reduce the runtime of the algorithm. For instances 1, 2, 10, and 12, runtimes are reduced by 107, 761, 106, and 1,635 seconds. Our lower bounding rule can increase the runtime of the algorithm—for instances 3 and 6, runtimes are increased by 185 and 378 seconds. Our lower bounding rule consistently reduces the number of MINLPs solved, but if these MINLPs are quickly deemed infeasible by SCIP (Achterberg, 2009), the additional time spent computing lower bounds for each partial order visited becomes an overhead.

Table 5 reports the results of the relaxed margin-stv algorithm (with bilinear terms replaced by McCormick (1976) inequalities) in each STV instance of Table 4, without and with the lower bounding rule of Section 7.1. CPLEX 12.5 is used to solve all DistanceToSTV MIPs formed by our margin-stv relaxations. We report the lower bound on the MOV found by margin-stv alongside the exact MOV (or bounds on the exact MOV) reported in Table 4. The lower bounds found by margin-stv (with McCormick (1976) inequalities) are often significantly lower than the exact MOV. Our lower bounding rule is beneficial in this setting – it often discovers tighter lower bounds on partial and complete orders than the MIP relaxation of DistanceToSTV (in 7/16 instances, applying the lower bounding rule results in a tighter lower bound being found by relaxed margin-stv), and reduces runtimes significantly for larger instances.

Relaxed margin-stv (with McCormick (1976) inequalities and our lower bounding rule) can compute a lower bound on the margin in each of our 16 STV instances within 12 hours. However, in 5/16 instances a trivial lower bound of 0 is found. We consider whether solving a piecewise linear relaxation of each DistanceToSTV MINLP, as described in Section 8.1, results in margin-stv finding better lower bounds. Table 6 reports the results of piecewise-relaxed margin-stv (with the use of our lower bounding rule) given varying $K$ (with higher values of $K$ forming a more accurate relaxation of each DistanceToSTV MINLP). In general, the resulting MOV lower bounds increase as $K$ increases. The counter-example is instance 16, for which margin-stv computes lower bounds of 760, 95, 17, and 0 for $K$ $=$ 5, 10, 15, and 20. As $K$ increases, the MIP relaxations solved throughout the algorithm become more complex and time consuming to solve. Consequently, margin-stv makes less progress through the space of partial orders in instance 16 within the 12 hour time limit. In the $K=5$ setting, margin-stv finds reasonable lower bounds in most instances. The exact MOV is found in 2 instances (11 and 15). In instance 13, we find a margin that lies within the bounds found on the MOV by the exact algorithm. Across instances 1 to 3, 6, 8 to 10, 12, and 16, the MOV lower bounds discovered are, on average, 14.4% below the exact MOV (or lower bound on the MOV found by the exact algorithm). In instances 4 and 5, piecewise-relaxed margin-stv finds trivial lower bounds of 0, however the exact MOV in these instances is small (63 and 59 votes, respectively).

9.1 Real-World STV Elections

In the preceding section we have evaluated margin-stv on a series of IRV elections (re-imagined as STV elections with 2 seats) held in the US between 2007 and 2010. The number of candidates in these elections range from 4 to 13. STV elections often involve a large number of candidates. In the 2012 election of senators to the ACT senate in Australia, 5-7 senators were elected in each of 3 districts. An STV election was held for each district, involving 20, 26, and 28 candidates. In the 2014 Victorian senate election in Australia, 5 senators were elected in each of 5 districts. The number of candidates in these elections ranged from 37 to 52. The use of margin-stv for elections of this size, without relaxation, is not feasible (due to the complexity of the DistanceToSTV MINLPs that must be solved). We demonstrate the value of our margin-stv algorithm for computing lower bounds on the margin in a number of real-world STV elections.

In addition to the use of MINLP relaxations (McCormick (1976) inequalities and piecewise-linear relaxations), we parallelise the exploration of the frontier of partial candidate orders. In place of selecting one partial candidate order to expand (at Step 13 of Figure 3), we select the first $N_{F}$ (where $N_{F}$ is a parameter) orders in the frontier $F$. Each of these orders is expanded in parallel, and the frontier updated accordingly – the children of all expanded orders with DistanceToSTV evaluations that are less than the current upper bound are inserted into the frontier. This upper bound is revised, and orders pruned from the frontier, when a complete order is found with a DistanceToSTV evaluation that is lower than the current upper bound.

The number of variables and constraints in the DistanceToSTV models solved by margin-stv is determined by the number of candidates in the orders being evaluated. In most STV elections, the number of available seats is much less than the number of candidates. Consequently, these orders will contain lengthy sequences of candidate eliminations. To limit the memory and solve time requirements of the DistanceToSTV models formed by margin-stv, we group these sequences of eliminated candidates together, ignoring constraints that enforce their relative elimination order (i.e., these candidates are effectively eliminated in a single round of counting). Grouping eliminated candidates together reduces the number of constraints required, and significantly reduces the number of vote equivalence classes that need to be considered, in each DistanceToSTV model. This grouping adds an additional level of relaxation to the algorithm.

We consider, in this section, the performance of margin-stv on 28 STV elections. We consider: the 2013 and 2016 election of 2 candidates to the Federal Senate for the Australian Capital Territory (ACT) and Northern Territory (NT); the 2002 election of 4, 3, and 5 candidates to the lower house of the Irish parliament (the Dáil Éireann) representing the Dublin North, Dublin West, and Meath constituencies; and 21 STV elections electing 3 to 4 candidates (out of 8 to 13, per ward) to the Glasgow City Council in 2007. Data for the Irish and Scottish STV elections were obtained from PrefLib333www.preflib.org. In each experiment reported in this section, margin-stv has been afforded a time limit of 24 hours. If this time limit is reached, and the algorithm has not converged, we report the best lower bounds on the MOV computed in that time period. Unless otherwise stated, we set $N_{F}=5$ and run margin-stv with increasing values of $K$ (from $K=5$ to $K=100$) until the resulting lower bound does not improve, or is within 10% of the best known upper bound.

9.2 2002 Irish General Election

We first consider the 2002 election of 4, 3, and 5 candidates (out of 13, 9, and 15) to the Irish lower house to represent Dublin North, Dublin West, and Meath. Table 7 reports, for each election, the quota, number of votes cast, and the best known upper bound on the MOV (computed as per Figure 2 and Section 5). For increasing values of $K$, we report the lower bound on the MOV computed by margin-stv over a 24 hour period, the runtime (in seconds) of the algorithm (if less than 24 hours), and the number of MIPs solved.

9.3 2007 Glasgow City Council

In the 2007 Glasgow City Council election, 3 to 4 candidates (out of 8 to 13) were elected in 21 STV elections (one for each of 21 wards). Tables 8 and 9 report the quota, number of votes cast, and the best known upper bound on the MOV (computed as per Figure 2 and Section 5). For increasing values of $K$, we report the lower bound on the MOV computed by margin-stv over a 24 hour period, the runtime (in seconds) of the algorithm (if less than 24 hours), and the number of MIPs solved. Instances where the MOV lower bound computed within 24 hours reduces as $K$ is increased are marked with an asterisk. Increasing $K$ increases the complexity, and solve times, of the MIPs being solved. These instances demonstrate that, as $K$ increases, the branch-and-bound search conducted by margin-stv may make less progress over the 24 hour period, resulting in a lower (rather than improved) lower bound on the MOV.

9.4 2013 and 2016 NT and ACT Federal Senate

Table 10 reports lower bounds on the MOV computed for the 2013 and 2016 ACT and NT Federal Senate elections. While these elections have a small number of seats (2), there are many candidates (between 19 and 27). In each of these elections, the two winning candidates have orders of magnitude more votes in their initial tallies than all others. We expect the margin in these elections to be reasonably high (certainly greater than a few hundred votes) as we need to change enough votes to ensure one of these candidates is not awarded a seat (and that one alternate candidate is awarded a seat). The MOV lower bounds found by margin-stv in Table 10 are likely to be much lower than the true margins.

The elections of Table 10 follow a similar pattern – a candidate is awarded a seat in the first round of counting, and then a long sequence of candidates are eliminated before a second candidate achieves a quota and is awarded a seat. In these circumstances, we can compute a lower bound on the MOV under the assumption that we cannot change who is elected and eliminated in the first $R$ rounds of counting. For large values of $R$, this assumption prunes significant portions of the space of possible elimination and election sequences from consideration. Consider the 2013 ACT election, in which the two available seats are awarded in rounds 1 and 24. If we assumed the first 20 rounds ($R=20$) are fixed (i.e., the first winner is elected in round 1, and the candidates eliminated in rounds 2 to 20 are still eliminated, at some point, between rounds 2 to 20), Table 11 reports our computed lower bounds on the MOV for this election.

The lower bounds reported in Table 11, for the 2013 ACT Federal Senate election, are not guaranteed lower bounds on the true margin of victory of the election. If we take the minimal manipulation discovered by margin-stv in the $K=80$ case, and simulate the modified election with the suggested vote changes put in place, we find that the original winning candidates ($c^{1}_{w}$ and $c^{2}_{w}$) are given a seat (in rounds 1 and in the last round). However, the tallies of $c^{2}_{w}$ and the runner up $c_{r}$, at the point at which $c_{r}$ is eliminated differ in only 159 votes. We consider an additional manipulation that awards 80 additional first preference votes to the runner up $c_{r}$, and removes 80 first preference votes from $c^{2}_{w}$ (we effectively swap 80 votes that ranked $c^{2}_{w}$ first with a ranking that has $c_{r}$ in first place). Simulating this modified election gives us a different outcome, with candidates $c^{1}_{w}$ and $c_{r}$ elected to a seat (in rounds 1 and in the last round). For this election, we now know that the MOV is no more than 5,999 votes – we were able to find an alternate outcome by modifying 5,999 votes to an alternate ranking. The upper bounds found by the winner elimination upper bound method of Figure 2, and the simple upper bound method of Section 5, are much higher than the true MOV. This analysis suggests there are alternate ways of using margin-stv for computing lower and upper bounds on the MOV for large, and challenging, elections (with many seats or large numbers of candidates). In future work, we aim to explore this further.

10 Concluding Remarks

In this paper we develop an algorithm, margin-stv, for computing exact margins of victory in STV elections, assuming the use of the Inclusive Gregory method of surplus distribution. The algorithm is based on solving a mixed-integer nonlinear formulation for the problem of computing a minimal manipulation to achieve a desired election order. We are able to compute exact margins of victory for small elections, e.g. less than 12 candidates and 2 seats. For larger, real elections margin-stv is able to compute reasonable lower bounds within 24 hours (as demonstrated on 28 real-world STV elections). The algorithm struggles on elections with large numbers of candidates, essentially since the search space grows as the factorial of the number of candidates, but provides an important first step in tackling this important and challenging problem.

As future work we plan to adapt the margin-stv algorithm to answer specific questions such as the influence of instances of multiple-voting on election outcomes, and the impact of losing votes, similar to our prior work (Blom et al., 2016) on Instant Runoff Voting (IRV) elections. In addition, we aim to explore how applying the algorithm to the tail of an STV election (i.e., by fixing the elections and eliminations that occur in the first $R$ rounds of counting) can be used within a practical algorithm for computing improved lower and upper bounds on the MOV in challenging instances (with a large number of seats or candidates).

Appendix A US Election Data (2007 to 2010)

In the experiments of Section 9 we reimagine a series of 16 IRV elections conducted in the US between 2007 and 2010 as STV elections with 2 available seats. Table 12 records the name, number of candidates, and number of votes cast, for each of these 16 elections. Candidate numbers range between 4 and 13.