[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