The sincere ballot lost to the strategic one

# Self-authored for the EML case corpus (no external origin). A Borda-count
# election scores every ranked ballot exactly and elects the highest total, and a
# clear majority of voters put the same candidate first. What that majority could
# have won by misreporting its second choice is computed below.
#
# The count is careful. It reads every real ranked ballot; it awards two points
# for a first place, one for a second, none for a third, exactly as the rule says;
# it sums every ballot; and the intent is exactly 'the ranking reflects what
# voters truly prefer'.
#
# Borda rewards burying: the fifty-five voters who prefer A can rank their real
# second choice B last, and that misreport, not any change of preference, moves
# the win from B to A - so the honest ballot loses to the strategic one.

55 => voters_a_then_b_then_c
45 => voters_b_then_c_then_a

voters_a_then_b_then_c + voters_b_then_c_then_a => voters
voters_a_then_b_then_c * 2 => sincere_score_a
voters_a_then_b_then_c * 1 + voters_b_then_c_then_a * 2 => sincere_score_b
voters_b_then_c_then_a * 1 => sincere_score_c
voters_a_then_b_then_c * 2 => strategic_score_a
voters_b_then_c_then_a * 2 => strategic_score_b
voters_a_then_b_then_c * 1 + voters_b_then_c_then_a * 1 => strategic_score_c
voters_a_then_b_then_c => a_over_b_head_to_head
int(voters_a_then_b_then_c * 10000 / voters) => a_first_place_majority_per_myriad

"voters                          : " + str(voters) ^0
"  sincerely A, B, C             : " + str(voters_a_then_b_then_c) ^0
"  sincerely B, C, A             : " + str(voters_b_then_c_then_a) ^0
"A's first-place majority        : " + str(a_first_place_majority_per_myriad) + " per ten thousand" ^0
"A beats B head-to-head          : " + str(a_over_b_head_to_head) + " to " + str(voters_b_then_c_then_a) ^0
"" ^0
"Borda, every ballot sincere     : A " + str(sincere_score_a) + "  B " + str(sincere_score_b) + "  C " + str(sincere_score_c) + "  -> B wins" ^0
"Borda, A's voters bury B (A, C, B) : A " + str(strategic_score_a) + "  B " + str(strategic_score_b) + "  C " + str(strategic_score_c) + "  -> A wins" ^0
"what changed between the two    : what 55 voters wrote, not what they want" ^0
"" ^0

# ---- what the count verified ----

"the Borda count" ^0
"  reads : every real ranked ballot" ^0
"  scores : 2, 1, 0 for first, second, third, per rule" ^0
"  sums : every ballot" ^0
"  intent : the ranking reflects what voters truly prefer" ^0
"  ballots misscored : 0" ^0
"  verdict : B HAS THE HIGHEST SINCERE TOTAL, 145" ^0
"" ^0
"  scoring every ballot exactly by the rule is the part done" ^0
"  right here, and it is why 145 is B's true Borda total for" ^0
"  the ballots as written" ^0
"" ^0

# ---- what a misreport can buy ----

"burying the rival" ^0
"  A's voters truly prefer : A, then B, then C" ^0
"  what they can write instead : A, then C, then B" ^0
"  the points that move : 55 second-place points, from B to C" ^0
"  B's total : " + str(sincere_score_b) + " sincere, " + str(strategic_score_b) + " buried" ^0
"  A's total : " + str(sincere_score_a) + " either way" ^0
"  so the winner : B if A's voters tell the truth, A if they" ^0
"    do not" ^0
"" ^0

# ---- what the voters got ----

"the outcome" ^0
"  sincere ballots elect : B, whom " + str(a_over_b_head_to_head) + " of " + str(voters) + " voters rank" ^0
"    below A" ^0
"  strategic ballots elect : A, the head-to-head winner" ^0
"  is the sincere count wrong : no; it is exact" ^0
"  does the rule reward telling the truth : no; the majority" ^0
"    that reported honestly lost, and the same majority" ^0
"    misreporting would win" ^0
"" ^0

# ---- null control ----

# The same ballots under a pairwise-majority rule, where A beats B 55 to 45
# whether or not A's voters bury B - burying moves no head-to-head count.
1 => nc_winner_changes_with_the_misreport_under_borda
0 => nc_winner_changes_with_the_misreport_under_pairwise
55 => nc_a_over_b_sincere_or_buried

"null control - decide by pairwise majority" ^0
"  winner changes when A's voters bury B, Borda : " + str(nc_winner_changes_with_the_misreport_under_borda) ^0
"  winner changes when A's voters bury B, pairwise : " + str(nc_winner_changes_with_the_misreport_under_pairwise) ^0
"  A over B, sincere or buried : " + str(nc_a_over_b_sincere_or_buried) + " to " + str(voters_b_then_c_then_a) ^0
"  no preference changed; the rule stopped paying for a" ^0
"  second choice that could be moved" ^0
"" ^0

# ---- the rule ----

"what a Borda count guarantees" ^0
"  the winner has the highest point total for the ballots as" ^0
"    written : exactly, every ballot scored by the rule" ^0
"  the winner reflects what voters truly prefer : not" ^0
"    addressed; the rule pays for second places, so a bloc" ^0
"    that buries its true second choice moves " + str(sincere_score_b - strategic_score_b) + " points" ^0
"    off its rival, and the sincere majority loses to the" ^0
"    same majority misreporting" ^0
"" ^0

"a rule that rewards how a ballot is written, apart from what it means, makes the" ^0
"honest report the losing one; the count is exact on what was written, and what" ^0
"was written is now a move, not a preference" ^0
"" ^0

"It scores every ranked ballot exactly by the Borda rule - B's sincere total of " + str(sincere_score_b) ^0
"is correct. But the rule pays for second places, so A's " + str(voters_a_then_b_then_c) + "-voter majority can bury" ^0
"B and drop it to " + str(strategic_score_b) + " while A stays at " + str(strategic_score_a) + "; the honest ballots elected B, whom" ^0
"" + str(a_over_b_head_to_head) + " of " + str(voters) + " rank below A, until the rule stopped paying for what could be moved." ^0

voters_a_then_b_then_c = 55
voters_b_then_c_then_a = 45
voters = voters_a_then_b_then_c + voters_b_then_c_then_a
sincere_score_a = voters_a_then_b_then_c * 2
sincere_score_b = voters_a_then_b_then_c * 1 + voters_b_then_c_then_a * 2
sincere_score_c = voters_b_then_c_then_a * 1
strategic_score_a = voters_a_then_b_then_c * 2
strategic_score_b = voters_b_then_c_then_a * 2
strategic_score_c = voters_a_then_b_then_c * 1 + voters_b_then_c_then_a * 1
a_over_b_head_to_head = voters_a_then_b_then_c
a_first_place_majority_per_myriad = int(voters_a_then_b_then_c * 10000 / voters)
print("voters                          : " + str(voters))
print("  sincerely A, B, C             : " + str(voters_a_then_b_then_c))
print("  sincerely B, C, A             : " + str(voters_b_then_c_then_a))
print("A's first-place majority        : " + str(a_first_place_majority_per_myriad) + " per ten thousand")
print("A beats B head-to-head          : " + str(a_over_b_head_to_head) + " to " + str(voters_b_then_c_then_a))
print("")
print("Borda, every ballot sincere     : A " + str(sincere_score_a) + "  B " + str(sincere_score_b) + "  C " + str(sincere_score_c) + "  -> B wins")
print("Borda, A's voters bury B (A, C, B) : A " + str(strategic_score_a) + "  B " + str(strategic_score_b) + "  C " + str(strategic_score_c) + "  -> A wins")
print("what changed between the two    : what 55 voters wrote, not what they want")
print("")
print("the Borda count")
print("  reads : every real ranked ballot")
print("  scores : 2, 1, 0 for first, second, third, per rule")
print("  sums : every ballot")
print("  intent : the ranking reflects what voters truly prefer")
print("  ballots misscored : 0")
print("  verdict : B HAS THE HIGHEST SINCERE TOTAL, 145")
print("")
print("  scoring every ballot exactly by the rule is the part done")
print("  right here, and it is why 145 is B's true Borda total for")
print("  the ballots as written")
print("")
print("burying the rival")
print("  A's voters truly prefer : A, then B, then C")
print("  what they can write instead : A, then C, then B")
print("  the points that move : 55 second-place points, from B to C")
print("  B's total : " + str(sincere_score_b) + " sincere, " + str(strategic_score_b) + " buried")
print("  A's total : " + str(sincere_score_a) + " either way")
print("  so the winner : B if A's voters tell the truth, A if they")
print("    do not")
print("")
print("the outcome")
print("  sincere ballots elect : B, whom " + str(a_over_b_head_to_head) + " of " + str(voters) + " voters rank")
print("    below A")
print("  strategic ballots elect : A, the head-to-head winner")
print("  is the sincere count wrong : no; it is exact")
print("  does the rule reward telling the truth : no; the majority")
print("    that reported honestly lost, and the same majority")
print("    misreporting would win")
print("")
nc_winner_changes_with_the_misreport_under_borda = 1
nc_winner_changes_with_the_misreport_under_pairwise = 0
nc_a_over_b_sincere_or_buried = 55
print("null control - decide by pairwise majority")
print("  winner changes when A's voters bury B, Borda : " + str(nc_winner_changes_with_the_misreport_under_borda))
print("  winner changes when A's voters bury B, pairwise : " + str(nc_winner_changes_with_the_misreport_under_pairwise))
print("  A over B, sincere or buried : " + str(nc_a_over_b_sincere_or_buried) + " to " + str(voters_b_then_c_then_a))
print("  no preference changed; the rule stopped paying for a")
print("  second choice that could be moved")
print("")
print("what a Borda count guarantees")
print("  the winner has the highest point total for the ballots as")
print("    written : exactly, every ballot scored by the rule")
print("  the winner reflects what voters truly prefer : not")
print("    addressed; the rule pays for second places, so a bloc")
print("    that buries its true second choice moves " + str(sincere_score_b - strategic_score_b) + " points")
print("    off its rival, and the sincere majority loses to the")
print("    same majority misreporting")
print("")
print("a rule that rewards how a ballot is written, apart from what it means, makes the")
print("honest report the losing one; the count is exact on what was written, and what")
print("was written is now a move, not a preference")
print("")
print("It scores every ranked ballot exactly by the Borda rule - B's sincere total of " + str(sincere_score_b))
print("is correct. But the rule pays for second places, so A's " + str(voters_a_then_b_then_c) + "-voter majority can bury")
print("B and drop it to " + str(strategic_score_b) + " while A stays at " + str(strategic_score_a) + "; the honest ballots elected B, whom")
print("" + str(a_over_b_head_to_head) + " of " + str(voters) + " rank below A, until the rule stopped paying for what could be moved.")

voters                          : 100
  sincerely A, B, C             : 55
  sincerely B, C, A             : 45
A's first-place majority        : 5500 per ten thousand
A beats B head-to-head          : 55 to 45

Borda, every ballot sincere     : A 110  B 145  C 45  -> B wins
Borda, A's voters bury B (A, C, B) : A 110  B 90  C 100  -> A wins
what changed between the two    : what 55 voters wrote, not what they want

the Borda count
  reads : every real ranked ballot
  scores : 2, 1, 0 for first, second, third, per rule
  sums : every ballot
  intent : the ranking reflects what voters truly prefer
  ballots misscored : 0
  verdict : B HAS THE HIGHEST SINCERE TOTAL, 145

  scoring every ballot exactly by the rule is the part done
  right here, and it is why 145 is B's true Borda total for
  the ballots as written

burying the rival
  A's voters truly prefer : A, then B, then C
  what they can write instead : A, then C, then B
  the points that move : 55 second-place points, from B to C
  B's total : 145 sincere, 90 buried
  A's total : 110 either way
  so the winner : B if A's voters tell the truth, A if they
    do not

the outcome
  sincere ballots elect : B, whom 55 of 100 voters rank
    below A
  strategic ballots elect : A, the head-to-head winner
  is the sincere count wrong : no; it is exact
  does the rule reward telling the truth : no; the majority
    that reported honestly lost, and the same majority
    misreporting would win

null control - decide by pairwise majority
  winner changes when A's voters bury B, Borda : 1
  winner changes when A's voters bury B, pairwise : 0
  A over B, sincere or buried : 55 to 45
  no preference changed; the rule stopped paying for a
  second choice that could be moved

what a Borda count guarantees
  the winner has the highest point total for the ballots as
    written : exactly, every ballot scored by the rule
  the winner reflects what voters truly prefer : not
    addressed; the rule pays for second places, so a bloc
    that buries its true second choice moves 55 points
    off its rival, and the sincere majority loses to the
    same majority misreporting

a rule that rewards how a ballot is written, apart from what it means, makes the
honest report the losing one; the count is exact on what was written, and what
was written is now a move, not a preference

It scores every ranked ballot exactly by the Borda rule - B's sincere total of 145
is correct. But the rule pays for second places, so A's 55-voter majority can bury
B and drop it to 90 while A stays at 110; the honest ballots elected B, whom
55 of 100 rank below A, until the rule stopped paying for what could be moved.

Trace event types