[EM] Reversal Software output 6/9/1999
Steve Eppley
SEppley at alumni.caltech.edu
Wed Jun 9 18:05:07 PDT 1999
Hi,
I added Blake Cretney's "Path Voting" method (which is a
variation of Schulze's method) and Condorcet(Margins) into
my Reversal software.
"Cret" is Blake's Path Voting method. When calculating the
size of a pairwin, it uses the pairwise margin of victory.
(Schulze uses the number of voters who ranked the pairwinner
ahead of the pairloser.) Blake made a philosophical argument
for preferring pairwise margins of victory, but I don't find
it more compelling than the philosophical argument for
preferring pairwise support (or call it opposition, depending
on which side you're on). More important than philosophical
criteria, in my opinion, are other criteria we usually use
for comparing voting methods.
"Marg" is the Condorcet(Margins) variation. Hugh Tobin
wrote (long ago) that he preferred it more than CondorcetVA,
for the same philosophical reason that Blake prefers
Path Voting to Schulze.
Note that the only difference between Path Voting and
Schulze, in this software's tests, is whether they comply
with Mike Ossipoff's Strong Defensive Strategy criterion:
"A majority who prefer X more than Y should have a way
to defeat Y without any of them having to explicitly
rank any alternative i equal to or ahead of any
alternative preferred more than i."
(In this 3-alternative software, this means that the
supporters of the condorcet winner B can ensure that A
doesn't win merely by truncating B>A>C to B.) Schulze
and VA comply with SDSC, but Path Voting does not.
I intend to write software that tests for resistance to
truncation. It will assume all voters' sincere preferences
are "strict" (no pairwise indifference) but that some of
those with an ABC preference order may vote just A, and
will calculate when this can change the outcome from
sincere condorcet winner B to A. It is expected that
Path Voting and Condorcet(Margins) will prove less
resistant to truncation than Schulze and CondorcetVA.
The table below shows the latest output. (For the sake of
brevity I'm only posting the output for 33 voters.)
Below the table is a key to the columns.
Below the key is the subroutine which tallies Cret. (There
are some tabs used for indentation which may not display
as intended; sorry about that.)
It seems to me that I could shorten the subroutine, both for
Schulze and for Path Voting, by calculating each alternative's
"schulzewins + schulzeties/2" and electing the one(s) with
the highest score. Any comments?
--Steve
-----------------
VOTERS METHOD CWS REVERSALS JITWFOILED BACKFIRES AVGREV MINREV MINREVS JITWMINREV BORDAWORSE MINRBORDA FAILSDSC BORDAWORST BORDAAVG THWARTMAX THWARTAVG
33 Cope 27132 5788 5739 0 15.8 1 680 673 4008 250 3892 0.66 0.94 63.6 54.0
33 Cret 27132 8219 5662 0 20.4 2 560 308 4993 0 3462 0.71 0.97 63.6 53.3
33 Duma 27132 9749 6703 0 20.1 2 680 368 6523 120 1016 0.69 0.95 63.6 53.5
33 IVA 27132 6218 4926 0 21.6 2 120 60 5502 120 1364 0.63 0.88 72.7 55.3
33 Marg 27132 8219 5662 0 20.4 2 560 308 4993 0 3462 0.71 0.97 63.6 53.3
33 Nans 27132 8049 5989 0 21.0 2 316 160 6379 120 1798 0.69 0.92 63.6 54.2
33 Schz 27132 8219 5662 0 20.4 2 560 308 4993 0 0 0.71 0.97 63.6 53.3
33 TC1 27132 1896 1442 0 6.6 1 680 504 1800 621 0 0.40 0.80 93.9 62.1
33 TC2 27132 3876 2106 1943 11.2 1 732 386 3018 492 1070 0.48 0.89 84.8 58.3
33 VA 27132 8219 5662 0 20.4 2 560 308 4993 0 0 0.71 0.97 63.6 53.3
Key to RevStats columns
-----------------------
CWs = number of scenarios where B is the sincere condorcet winner
but not the favorite of a majority.
Reversals = number of scenarios where "ABC -> ACB" reversal can elect A.
(Smaller is better.)
JITWFoiled = number of scenarios where reversal would probably be
foiled by C voluntarily withdrawing. (CBA/C > 60%)
(Larger is better, but this is relative to Reversals.)
Backfires = number of scenarios where reversal can succeed but
too much reversing backfires by electing C.
AvgRev = average amount of reversing needed to succeed, expressed
as a percentage of the total voters.
(Larger is better.)
MinRev = minimum number of reversers needed to reverse at least
one scenario. (Larger is better.)
(I don't know if this stat matters. It's probably
3 or less regardless of how many voters there are.)
MinRevs = number of scenarios where the number of reversers needed
to successfully reverse equals MinRev.
(Smaller is better.)
(I don't know if this stat is useful, especially
since it depends on the method's MinRev.)
JITWMinRev = number of MinRevs scenarios where reversal would probably
be foiled by C voluntarily withdrawing.
(Larger is better, but this is relative to MinRevs.)
BordaWorse = number of reversal scenarios where A's sincere Borda score
is worse than B's. (Smaller is better.)
MinRBorda = number of MinRevs scenarios where A's sincere Borda score
is worse than B's. (Smaller is better.)
FailSDSC = number of scenarios where reversal isn't thwarted by
by BAC -> B>A=C truncation. (When voters are devious
enough to reverse, others will be clever enough to defend.)
If always zero for a method, the method satisfies
Mike Ossipoff's "Strong Defensive Strategy" criterion.
(Smaller is better.)
BordaWorst = smallest ratio of A's sincere Borda score to B's.
(Larger is better.)
BordaAvg = average ratio of A's sincere Borda score to B's.
(Larger is better.)
ThwartMax = largest percentage of voters who ranked B ahead of A.
(Smaller is better.)
ThwartAvg = average percentage of voters who ranked B ahead of A.
(Smaller is better.)
A caveat about the Borda and Thwarted Majority stats: A method with
more reversal scenarios may appear better on these stats. But in
scenarios where reversal fails, there is no drop in the winner's
sincere Borda score and no thwarted majority, so a method with fewer
reversal scenarios should perhaps receive extra credit in these
stats for its extra scenarios where reversal fails.
* * *
procedure Cretney
parameters nAB,nBA,nAC,nCA,nBC,nCB
* Blake Cretney's "Path Voting" method calculates the beat-paths
* between each pair of alternatives, just like Schulze.
* The difference here is that the size of a pairwin is the
* margin of victory in the pairing: nWL-nLW.
* The strength of a beat-path is the strength of its
* weakest link.
* If maxbeatpath(x>y) > maxbeatpath(y>x) then x shulze-beat y.
* The winner is the one which is shulze-unbeaten.
private cWinner, ABStrength,BAStrength,BCStrength, ;
CBStrength,CAStrength,ACStrength, ;
cABwinner,cACwinner,cBCwinner
if nBC>nCB
* Too little reversal to make a difference.
RETURN 'B'
endif
* There is a cycle: B>A, C>=B, A>=C
if nBC>=nCB
* B has no pairlosses so given Path Voting B wins.
RETURN 'B'
endif
if nAC<=nCA
* Only C has no pairlosses so given Path Voting C wins.
RETURN 'C'
endif
* Here if each alternative has a pairwin and a pairloss.
* Calculate and compare the beat-paths, using margins of victory:
BAStrength = nBA-nAB
ACStrength = nAC-nCA
CBStrength = nCB-nBC
ABStrength = min(ACStrength,CBStrength)
CAStrength = min(CBStrength,BAStrength)
BCStrength = min(BAStrength,ACStrength)
cABwinner = iif(BAStrength<ABStrength, 'A', iif(BAStrength>ABStrength, 'B', 'AB'))
cACwinner = iif(ACStrength<CAStrength, 'C', iif(ACStrength>CAStrength, 'A', 'AC'))
cBCwinner = iif(CBStrength<BCStrength, 'B', iif(CBStrength>BCStrength, 'C', 'BC'))
if at('A',cABwinner) = 0
* B schulze-beat A
if at('B',cBCwinner) = 0
* C schulze-beat B
RETURN 'C'
else
* C did not schulze-beat B
* B has no schulze-losses so either B wins or B ties C.
RETURN 'B'
endif
else
* B did not schulze-beat A
if at('B',cABwinner) = 0
* A schulze-beat B
if at('A',cACwinner) = 0
* C schulze-beat A
RETURN 'C'
else
* C did not schulze-beat A
* A has no schulze-losses. Either A wins or A ties:
if at('C',cACwinner) = 0
* A schulze-beat C
RETURN 'A'
else
* A schulze-tied C
if at('C',cBCwinner) = 0
* B schulze-beat C
* Only A has no schulze-losses.
RETURN 'A'
else
* Neither A nor C has any schulze-losses.
* Ignore this tie scenario.
RETURN 'B'
endif
endif
endif
else
* A schulze-tied B
if at('B',cBCwinner) = 0
* C schulze-beat B
if at('C',cACwinner) = 0
* A schulze-beat C
* Only A has no schulze-losses.
RETURN 'A'
else
* A did not schulze-beat C
if at('A',cACwinner) = 0
* C schulze-beat A
RETURN 'C'
else
* A schulze-tied C
* Neither A nor C has any schulze-losses.
* Ignore this tie scenario.
RETURN 'B'
endif
endif
else
* C did not schulze-beat B
* B has no schulze-losses, so either B wins or B ties.
RETURN 'B'
endif
endif
endif
* Should never get to here, but put a return at the end anyway:
RETURN 'B'
More information about the Election-Methods
mailing list