Skip to content

Bloc STAR — a three-way tie no rung can break (484mbm)

Method: Bloc STAR (multi-winner, majoritarian) · 2 seats · Expected winners: Blythe, Arden · full count →

Three voters, three candidates, rotating ballots — so scores, pairwise and five-star all come back level and the two seats are filled entirely by tie-break policy. Built to compare what the engines do when the ballots say nothing: BetterVoting skips the pairwise rung and draws lots; Larry Hastings' own CLI, with the tiebreaker switched off, declines to pick anyone at all.

▶ Live on BetterVoting: vote · results ↗ (election 484mbm).

Reference files: b484mbm_tie_every_rung.yaml (expected_winners: [Blythe, Arden]) · frozen export b484mbm_tie_every_rung_bv_export.json (BV 484mbm) · full generated page cases_pages/b484mbm_tie_every_rung.md. Companion to the input-format page The .starvote ballot file format, which runs the same election through upstream's CLI.

Ignore the BV number in this election's title

The BetterVoting page is permanently titled "BV2263 — …", and that number is wrong: BV2263 was minted the same afternoon for the over-50% control (xw23m9), and BV titles cannot be edited or deleted. This case is therefore filed under its bvid, which is unique by construction. Quote 484mbm; ignore the BV number printed on the election.

The election

Bloc STAR, 3 candidates, 2 seats, 3 ballots:

Arden,Blythe,Corin
3,4,5
5,3,4
4,5,3

Each voter spends the same 3 / 4 / 5 on a different candidate, rotated one step — Arden > Blythe > Corin > Arden, rock-paper-scissors. Every symmetry a tie-break rung can measure therefore holds exactly:

Rung Arden Blythe Corin Separates?
Total score 12 12 12 no
Pairwise ballot-preferences 3 3 3 no
Head-to-head wins 1 1 1 no — a Condorcet cycle
Five-star votes 1 1 1 no

Nothing in the ballots distinguishes the three candidates, so whoever fills the two seats is chosen by the tie-break policy, not by the voters. That is the point of the case: it zeroes out everything else so the policy is all that is left.

The case file

The YAML the engine actually runs, embedded at build time — so the parameters on this page can never drift from the file:

cases/b484mbm_tie_every_rung.yaml
election_title: "3 candidates / 2 seats, Bloc STAR — tie at every rung (484mbm)"

# BV tracker fields (read by tools_adam/scripts/build_bv_registry.py; engine ignores).
# No bv_test_id on purpose: this case is named by its bvid, which is unique by
# construction. The election's PERMANENT BetterVoting title reads "BV2263 — …",
# which is wrong — BV2263 was minted concurrently for the over-50% control
# (xw23m9) and a BV title cannot be edited or deleted. `484mbm` is the id to
# quote; the number on the BV page should be ignored.
bv_election_id: 484mbm
bv_results_url: https://bettervoting.com/484mbm/results

scenario_description: |-
  The smallest election that ties all the way down. Three voters, three
  candidates, two seats; the ballots rotate, so each voter's 3 / 4 / 5 lands on a
  different candidate (Arden > Blythe > Corin > Arden, rock-paper-scissors).

  Every deterministic rung comes back level. Scores: 12 = 12 = 12. Pairwise: each
  candidate is preferred on 3 of the 9 matchup-ballots, and each wins exactly one
  head-to-head 2-1, so the cycle ties on either reading. Five-star: one score-5
  vote each. Nothing in the ballots separates the three, so the two seats are
  filled entirely by whatever tie-breaking policy was published before the count.

  That makes it a clean divergence probe, and the two engines take different
  paths to the same pair. BetterVoting SKIPS the pairwise rung whenever more than
  two candidates are tied (log `pairwise_too_many_candidates`), falls through
  five-star, and settles seat 1 with its seeded random draw
  perm = [Blythe, Arden, Corin] -> Blythe, then Arden. The LH engine DOES compute
  the pairwise rung, finds it tied 3-3-3, and only then reaches its own
  tiebreaker. Pinning lot_numbers to BV's perm reproduces BV exactly.

  Also a live repro of the tieBreakType reporting gap already seen on BV130-r2:
  round 0 carries `tieBreakType: "random"` and the logs name both draws, but the
  top-level `tieBreakType` is `"none"` and `tied` is `[]` — so the summary a
  reader sees does not say a seat was decided by lot.

  Backs the .starvote input-format page, which runs the same election through
  Larry Hastings' own CLI with the tiebreaker switched off, where it refuses to
  pick anyone at all:
  07_Concepts/tabulation_engines/LH_starvote/starvote_file_format.md

num_winners: 2
voting_method: Bloc STAR
lot_numbers: [Blythe, Arden, Corin]   # BV's drawn perm — reproduces Blythe, Arden
ballots: |-
  Arden,Blythe,Corin
  3,4,5
  5,3,4
  4,5,3

expected_winners:
  - Blythe
  - Arden

# file: b484mbm_tie_every_rung.yaml

View 1 — BetterVoting

Elected Blythe and Arden. The scoring round shows the flat 12/12/12, and the runoff card then shows Blythe 67% vs Arden 33%:

BetterVoting results for 484mbm: Blythe and Arden win; scoring round shows Blythe 12, Arden 12, Corin 12; automatic runoff shows Blythe 67% vs Arden 33%

Round 0's logs are where the mechanism actually shows — score_tied on all three at 12, then pairwise_too_many_candidates, then five_star_tied at 1 each, then random_first: Blythe and random_second: Arden drawn from all three, and finally the 2–1 runoff.

Two things worth naming.

BetterVoting skips the pairwise rung when more than two candidates are tied. It does not compute the three-way pairwise comparison at all — it falls straight through to five-star, then to the draw. The LH engine does compute it, and reports it tied 3–3–3. Here the shortcut costs nothing because the rung was tied anyway; it is a genuine ladder difference all the same, and on a ballot set where the pairwise rung would separate three tied candidates, the two engines would part ways.

The summary does not say a seat was decided by lot. Round 0 carries tieBreakType: "random" and perm: [Blythe, Arden, Corin], but the top-level tieBreakType is "none" and top-level tied is []. A reader who lands on the public results page sees a flat 12/12/12 followed by a Blythe-vs-Arden runoff with nothing saying those two finalists were drawn rather than earned. That is the same reporting gap already recorded on BV130-r2, reproduced here in three ballots — and the draw is a seeded shuffle, so re-tallying reproduces the same order rather than exposing the randomness.

View 2 — the LH report

Pinning lot_numbers to BV's drawn perm reproduces BetterVoting exactly — Blythe, Arden — which is what makes the two views comparable rather than coincidental. The engine prints the pairwise rung BV skipped, and flags the lot itself with a ⚠ Lot-decided tie — rare warning naming the fallback it used.

The full audit, embedded from the _tabulated mirror rather than pasted, so it tracks the engine:

cases/cases_tabulated/b484mbm_tie_every_rung_tabulated.txt
======================================================================
SOURCE FILE:     b484mbm_tie_every_rung.yaml
TABULATED FILE:  b484mbm_tie_every_rung_tabulated.txt
======================================================================

election_title: "3 candidates / 2 seats, Bloc STAR — tie at every rung (484mbm)"

# BV tracker fields (read by tools_adam/scripts/build_bv_registry.py; engine ignores).
# No bv_test_id on purpose: this case is named by its bvid, which is unique by
# construction. The election's PERMANENT BetterVoting title reads "BV2263 — …",
# which is wrong — BV2263 was minted concurrently for the over-50% control
# (xw23m9) and a BV title cannot be edited or deleted. `484mbm` is the id to
# quote; the number on the BV page should be ignored.
bv_election_id: 484mbm
bv_results_url: https://bettervoting.com/484mbm/results

scenario_description: |-
  The smallest election that ties all the way down. Three voters, three
  candidates, two seats; the ballots rotate, so each voter's 3 / 4 / 5 lands on a
  different candidate (Arden > Blythe > Corin > Arden, rock-paper-scissors).

  Every deterministic rung comes back level. Scores: 12 = 12 = 12. Pairwise: each
  candidate is preferred on 3 of the 9 matchup-ballots, and each wins exactly one
  head-to-head 2-1, so the cycle ties on either reading. Five-star: one score-5
  vote each. Nothing in the ballots separates the three, so the two seats are
  filled entirely by whatever tie-breaking policy was published before the count.

  That makes it a clean divergence probe, and the two engines take different
  paths to the same pair. BetterVoting SKIPS the pairwise rung whenever more than
  two candidates are tied (log `pairwise_too_many_candidates`), falls through
  five-star, and settles seat 1 with its seeded random draw
  perm = [Blythe, Arden, Corin] -> Blythe, then Arden. The LH engine DOES compute
  the pairwise rung, finds it tied 3-3-3, and only then reaches its own
  tiebreaker. Pinning lot_numbers to BV's perm reproduces BV exactly.

  Also a live repro of the tieBreakType reporting gap already seen on BV130-r2:
  round 0 carries `tieBreakType: "random"` and the logs name both draws, but the
  top-level `tieBreakType` is `"none"` and `tied` is `[]` — so the summary a
  reader sees does not say a seat was decided by lot.

  Backs the .starvote input-format page, which runs the same election through
  Larry Hastings' own CLI with the tiebreaker switched off, where it refuses to
  pick anyone at all:
  07_Concepts/tabulation_engines/LH_starvote/starvote_file_format.md

num_winners: 2
voting_method: Bloc STAR
lot_numbers: [Blythe, Arden, Corin]   # BV's drawn perm — reproduces Blythe, Arden
ballots: |-
  Arden,Blythe,Corin
  3,4,5
  5,3,4
  4,5,3

expected_winners:
  - Blythe
  - Arden

# file: b484mbm_tie_every_rung.yaml

======================================================================
TABULATION RESULTS
======================================================================

=== 3 candidates / 2 seats, Bloc STAR — tie at every rung (484mbm) ===
  The smallest election that ties all the way down. Three voters, three
  candidates, two seats; the ballots rotate, so each voter's 3 / 4 / 5 lands on a
  different candidate (Arden > Blythe > Corin > Arden, rock-paper-scissors).

  Every deterministic rung comes back level. Scores: 12 = 12 = 12. Pairwise: each
  candidate is preferred on 3 of the 9 matchup-ballots, and each wins exactly one
  head-to-head 2-1, so the cycle ties on either reading. Five-star: one score-5
  vote each. Nothing in the ballots separates the three, so the two seats are
  filled entirely by whatever tie-breaking policy was published before the count.

  That makes it a clean divergence probe, and the two engines take different
  paths to the same pair. BetterVoting SKIPS the pairwise rung whenever more than
  two candidates are tied (log `pairwise_too_many_candidates`), falls through
  five-star, and settles seat 1 with its seeded random draw
  perm = [Blythe, Arden, Corin] -> Blythe, then Arden. The LH engine DOES compute
  the pairwise rung, finds it tied 3-3-3, and only then reaches its own
  tiebreaker. Pinning lot_numbers to BV's perm reproduces BV exactly.

  Also a live repro of the tieBreakType reporting gap already seen on BV130-r2:
  round 0 carries `tieBreakType: "random"` and the logs name both draws, but the
  top-level `tieBreakType` is `"none"` and `tied` is `[]` — so the summary a
  reader sees does not say a seat was decided by lot.

  Backs the .starvote input-format page, which runs the same election through
  Larry Hastings' own CLI with the tiebreaker switched off, where it refuses to
  pick anyone at all:
  07_Concepts/tabulation_engines/LH_starvote/starvote_file_format.md

--- Preference Matrix ---
Head-to-head / pairwise comparison
Legend: For - Equal Support - Against
        Informational only — not part of the 2-winner count below,
        so no Top-2 finalists are marked.
               |    Arden   |   Blythe  |   Corin   |
-----------------------------------------------------
       Arden > |    ---     |1 - 0 - 2  |2 - 0 - 1  |
      Blythe > | 2 - 0 - 1  |   ---     |1 - 0 - 2  |
       Corin > | 1 - 0 - 2  |2 - 0 - 1  |   ---     |

[Condorcet Winner]
  No Condorcet winner (majority cycle: Arden > Corin > Blythe > Arden)

--- Bloc STAR Voting Method (2 winners) ---
[Bloc STAR]
 Tabulating 3 ballots to fill 2 seats.
Arden,Blythe,Corin
    3,     4,    5
    5,     3,    4
    4,     5,    3

[Score Distribution] (how many ballots gave each star rating)
                Score
Candidate  5  4  3  2  1  0  | Total   Avg
Arden      1  1  1  0  0  0  |    12   4.0
Blythe     1  1  1  0  0  0  |    12   4.0
Corin      1  1  1  0  0  0  |    12   4.0

[Bloc STAR: Round 1: Scoring Round]
 The two highest-scoring candidates advance to the next round.
   Arden         -- 12 -- Tied for first place
   Blythe        -- 12 -- Tied for first place
   Corin         -- 12 -- Tied for first place
 There's a three-way tie for first.

[Bloc STAR: Round 1: Scoring Round: First tiebreaker]
 The two candidates preferred in the most head-to-head matchups advance.
   Arden         -- 3 -- Tied for first place
   Blythe        -- 3 -- Tied for first place
   Corin         -- 3 -- Tied for first place
   Equal Support -- 0
 There's still a three-way tie for first.

[Bloc STAR: Round 1: Scoring Round: Second tiebreaker]
 The two candidates with the most votes of score 5 advance.
   Arden         -- 1 -- Tied for first place
   Blythe        -- 1 -- Tied for first place
   Corin         -- 1 -- Tied for first place
 There's still a three-way tie for first.

*(Ties are resolved by choosing the tied candidate with the highest-priority official lot number.)*
    Lot-number priority order: ['Blythe', 'Arden', 'Corin']

[Tiebreaker: Lot Number Priority]
  Tie among: ['Arden', 'Blythe', 'Corin']
  Resolved: ['Blythe', 'Arden'] (selected by lot-number priority).

[Lot-decided tie — rare]
  ⚠ The ballots did not break this tie: the deterministic rungs
    (pairwise / score, then five-star) all came back equal, so the
    pre-published LOT order chose among the tied candidates — the
    result here was set by lot, not by the votes. Usually the
    "dead rung": no tied candidate held a score-5 vote (five-star
    counts fives, not fours). Verify the tied candidates' 5-counts.

[Bloc STAR: Round 1: Automatic Runoff Round]
 The candidate preferred in the most head-to-head matchups wins.
   Blythe        -- 2 -- First place
   Arden         -- 1
   Equal Support -- 0
 Blythe wins.
   Runoff math:
     3  ballots cast
   − 0  Equal Support (no preference between the two finalists)
     ─
     3  voters with a preference  (majority = 2)
           Blythe 2 (67%)  ·  Arden 1 (33%)

──────────────────────────────────────────────────
[Bloc STAR: Round 2: Scoring Round]
 The two highest-scoring candidates advance to the next round.
   Arden         -- 12 -- First place
   Corin         -- 12 -- Second place
 Arden and Corin advance.

[Bloc STAR: Round 2: Automatic Runoff Round]
 The candidate preferred in the most head-to-head matchups wins.
   Arden         -- 2 -- First place
   Corin         -- 1
   Equal Support -- 0
 Arden wins.
   Runoff math:
     3  ballots cast
   − 0  Equal Support (no preference between the two finalists)
     ─
     3  voters with a preference  (majority = 2)
           Arden 2 (67%)  ·  Corin 1 (33%)

[Bloc STAR: Winners — Bloc STAR Voting Method (2 winners)]
 Blythe
 Arden

The third answer: refuse

Upstream's own CLI has an option the repo wrapper does not expose — tiebreaker = none, which makes an undecidable tie an error rather than a draw. Run this election through it and it stops at Unbreakable Tie without naming a winner.

So the same three ballots produce four different outcomes depending only on policy: nobody (tiebreaker = none), Arden + Corin (hashed_ballots, upstream's default), and Blythe + Arden twice over — once from BV's seeded draw, once from the wrapper's column-order lot fallback. The walk-through, and the .starvote file that produces it, are on The .starvote ballot file format.